#include <arc.h>

Classes
struct	Iteration

Public Member Functions
	Arc (const Rect &bounds, Degrees start, Degrees sweep, bool include_center)

const Rect &	GetOvalBounds () const
	Return the bounds of the oval in which this arc is inscribed. More...

const Point	GetOvalCenter () const
	Returns the center of the oval bounds. More...

const Size	GetOvalSize () const
	Returns the size of the oval bounds. More...

Rect	GetTightArcBounds () const

constexpr Degrees	GetStart () const

constexpr Degrees	GetSweep () const

constexpr bool	IncludeCenter () const

constexpr bool	IsPerfectCircle () const

constexpr bool	IsFullCircle () const

Iteration	ComputeIterations (size_t step_count, bool simplify_360=true) const

Detailed Description

Definition at line 13 of file arc.h.

Constructor & Destructor Documentation

◆ Arc()

impeller::Arc::Arc	(	const Rect &	bounds,
		Degrees	start,
		Degrees	sweep,
		bool	include_center
	)

Definition at line 9 of file arc.cc.

     : bounds_(bounds), include_center_(include_center) {
   if (bounds.IsFinite() && start.IsFinite() && sweep.IsFinite()) {
     if (sweep.degrees < 0) {
       start = start + sweep;
       sweep = -sweep;
     }
     if (sweep.degrees > 360) {
       // We need to represent over-sweeping a full circle for the case where
       // we will be stroking the circle with the center incuded where we
       // stroke the entire perimeter, but the two segments that connect to
       // the center are at the proper angles.
       // Normalize to less than 720.
       sweep.degrees = 360.0f + std::fmodf(sweep.degrees, 360.0f);
     }
   } else {
     // Don't bother sweeping any distance if anything is non-finite.
     sweep = Degrees(0);
     if (!start.IsFinite() || !bounds.IsFinite()) {
       // We can maintain start if both it and bounds are finite.
       start = Degrees(0);
     }
   }
   start_ = start;
   sweep_ = sweep;
 }

References impeller::Degrees::degrees, impeller::TRect< T >::IsFinite(), impeller::Degrees::IsFinite(), and start.

Member Function Documentation

◆ ComputeIterations()

Arc::Iteration impeller::Arc::ComputeIterations	(	size_t	step_count,
		bool	simplify_360 = `true`
	)		const

Return an |ArcIteration| that explains how to generate vertices for the arc with the indicated number of steps in each full quadrant. The step_count is typically chosen based on the size of the bounds and the scale at which the arc is being drawn and so the computation of the step_count requirements is left to the caller.

If the sweep is more than 360 degrees then the code may simplify the iteration to a simple circle, but only if the simplify_360 parameter is true.

Definition at line 102 of file arc.cc.

                                                                {
   if (sweep_.degrees == 0) {
     return {};
   }
  
   FML_DCHECK(sweep_.degrees >= 0);
  
   if (simplify_360 && sweep_.degrees >= 360) {
     return ComputeCircleArcIterations(step_count);
   }
   FML_DCHECK(sweep_.degrees < 720);
  
   Degrees start = start_.GetPositive();
   Degrees end = start + sweep_;
   FML_DCHECK(start.degrees >= 0.0f && start.degrees < 360.0f);
   FML_DCHECK(end >= start);
   FML_DCHECK(end.degrees < start.degrees + (simplify_360 ? 360.0f : 720.0f));
  
   Iteration iterations;
   iterations.start = impeller::Matrix::CosSin(start);
   iterations.end = impeller::Matrix::CosSin(end);
  
   // We nudge the start and stop by 1/10th of a step so we don't end
   // up with degenerately small steps at the start and end of the
   // arc.
   Degrees nudge = Degrees((90.0f / step_count) * 0.1f);
  
   if ((start + nudge) >= (end - nudge)) {
     iterations.quadrant_count = 0u;
     return iterations;
   }
  
   int cur_quadrant =
       static_cast<int>(std::floor((start + nudge).degrees / 90.0f));
   int end_quadrant =
       static_cast<int>(std::floor((end - nudge).degrees / 90.0f));
   FML_DCHECK(cur_quadrant >= 0 &&  //
              cur_quadrant <= 4);
   FML_DCHECK(end_quadrant >= cur_quadrant &&  //
              end_quadrant <= cur_quadrant + 8);
   FML_DCHECK(cur_quadrant * 90 <= (start + nudge).degrees);
   FML_DCHECK(end_quadrant * 90 + 90 >= (end - nudge).degrees);
  
   auto next_step = [step_count](Degrees angle, int quadrant) -> size_t {
     Scalar quadrant_fract = angle.degrees / 90.0f - quadrant;
     return static_cast<size_t>(std::ceil(quadrant_fract * step_count));
   };
  
   int i = 0;
   iterations.quadrants[i] = {
       kQuadrantAxes[cur_quadrant & 3],
       next_step(start + nudge, cur_quadrant),
       step_count,
   };
   if (iterations.quadrants[0].end_index > iterations.quadrants[0].start_index) {
     i++;
   }
   while (cur_quadrant < end_quadrant) {
     iterations.quadrants[i++] = {
         kQuadrantAxes[(++cur_quadrant) % 4],
         0u,
         step_count,
     };
   }
   FML_DCHECK(i <= 9);
   if (i > 0) {
     iterations.quadrants[i - 1].end_index =
         next_step(end - nudge, cur_quadrant);
     if (iterations.quadrants[i - 1].end_index <=
         iterations.quadrants[i - 1].start_index) {
       i--;
     }
   }
   iterations.quadrant_count = i;
   return iterations;
 }

References impeller::Matrix::CosSin(), impeller::Degrees::degrees, impeller::Arc::Iteration::end, end, impeller::Arc::Iteration::Quadrant::end_index, impeller::Degrees::GetPositive(), impeller::kQuadrantAxes, impeller::Arc::Iteration::quadrant_count, impeller::Arc::Iteration::quadrants, impeller::Arc::Iteration::start, start, and impeller::Arc::Iteration::Quadrant::start_index.

Referenced by impeller::ArcStrokeGeometry::Dispatch(), impeller::Tessellator::FilledArc(), impeller::StrokePathSegmentReceiver::RecordArc(), impeller::Tessellator::StrokedArc(), and impeller::testing::TEST().

◆ GetOvalBounds()

const Rect& impeller::Arc::GetOvalBounds ( ) const

inline

Return the bounds of the oval in which this arc is inscribed.

Definition at line 94 of file arc.h.

94 { return bounds_; }

Referenced by impeller::Canvas::DrawArc(), impeller::Tessellator::FilledArc(), std::operator<<(), and impeller::Tessellator::StrokedArc().

◆ GetOvalCenter()

const Point impeller::Arc::GetOvalCenter ( ) const

inline

Returns the center of the oval bounds.

Definition at line 97 of file arc.h.

97 { return bounds_.GetCenter(); }

impeller::TRect::GetCenter

constexpr Point GetCenter() const

Get the center point as a |Point|.

Definition: rect.h:386

References impeller::TRect< T >::GetCenter().

Referenced by impeller::ArcStrokeGeometry::Dispatch().

◆ GetOvalSize()

const Size impeller::Arc::GetOvalSize ( ) const

inline

Returns the size of the oval bounds.

Definition at line 100 of file arc.h.

100 { return bounds_.GetSize(); }

impeller::TRect::GetSize

constexpr TSize< Type > GetSize() const

Returns the size of the rectangle which may be negative in either width or height and may have been c...

Definition: rect.h:331

References impeller::TRect< T >::GetSize().

Referenced by impeller::ArcStrokeGeometry::Dispatch(), impeller::Tessellator::FilledArc(), and impeller::Tessellator::StrokedArc().

◆ GetStart()

constexpr Degrees impeller::Arc::GetStart ( ) const

inlineconstexpr

Definition at line 106 of file arc.h.

106 { return start_; }

Referenced by impeller::Canvas::DrawArc(), and std::operator<<().

◆ GetSweep()

constexpr Degrees impeller::Arc::GetSweep ( ) const

inlineconstexpr

Definition at line 108 of file arc.h.

108 { return sweep_; }

Referenced by impeller::Canvas::DrawArc(), and std::operator<<().

◆ GetTightArcBounds()

Rect impeller::Arc::GetTightArcBounds ( ) const

Return the tight bounds of the arc taking into account its specific geometry such as the start and end angles and the center (if included).

Definition at line 59 of file arc.cc.

                                   {
   if (IsFullCircle()) {
     return bounds_;
   }
  
   Degrees start_angle = start_.GetPositive();
   Degrees end_angle = start_angle + sweep_;
   FML_DCHECK(start_angle.degrees >= 0 && start_angle.degrees < 360);
   FML_DCHECK(end_angle > start_angle && end_angle.degrees < 720);
  
   // 1. start vector
   // 2. end vector
   // 3. optional center
   // 4-7. optional quadrant extrema
   Point extrema[7];
   int count = 0;
  
   extrema[count++] = Matrix::CosSin(start_angle);
   extrema[count++] = Matrix::CosSin(end_angle);
  
   if (include_center_) {
     extrema[count++] = {0, 0};
   }
  
   // cur_axis will be pre-incremented before recording the following axis
   int cur_axis = std::floor(start_angle.degrees / 90.0f);
   // end_axis is a non-inclusive end of the range
   int end_axis = std::ceil(end_angle.degrees / 90.0f);
   while (++cur_axis < end_axis) {
     extrema[count++] = kQuadrantAxes[cur_axis & 3];
   }
  
   FML_DCHECK(count <= 7);
  
   Point center = bounds_.GetCenter();
   Size radii = bounds_.GetSize() * 0.5f;
  
   for (int i = 0; i < count; i++) {
     extrema[i] = center + extrema[i] * radii;
   }
   return Rect::MakePointBounds(extrema, extrema + count).value_or(Rect());
 }