impeller::skia_conversions Namespace Reference

Functions
bool	IsNearlySimpleRRect (const SkRRect &rr)
	Like SkRRect.isSimple, but allows the corners to differ by kEhCloseEnough. More...
Rect	ToRect (const SkRect &rect)
std::optional< Rect >	ToRect (const SkRect *rect)
std::vector< Rect >	ToRects (const SkRect tex[], int count)
std::vector< Point >	ToPoints (const SkPoint points[], int count)
PathBuilder::RoundingRadii	ToRoundingRadii (const SkRRect &rrect)
Path	ToPath (const SkPath &path, Point shift)
Path	ToPath (const SkRRect &rrect)
Point	ToPoint (const SkPoint &point)
Size	ToSize (const SkPoint &point)
Color	ToColor (const flutter::DlColor &color)
std::vector< Matrix >	ToRSXForms (const SkRSXform xform[], int count)
Path	PathDataFromTextBlob (const sk_sp< SkTextBlob > &blob, Point shift)
std::optional< impeller::PixelFormat >	ToPixelFormat (SkColorType type)
void	ConvertStops (const flutter::DlGradientColorSourceBase *gradient, std::vector< Color > &colors, std::vector< float > &stops)
	Convert display list colors + stops into impeller colors and stops, taking care to ensure that the stops monotonically increase from 0.0 to 1.0. More...

Function Documentation

ConvertStops()

void impeller::skia_conversions::ConvertStops	(	const flutter::DlGradientColorSourceBase *	gradient,
		std::vector< Color > &	colors,
		std::vector< float > &	stops
	)

Convert display list colors + stops into impeller colors and stops, taking care to ensure that the stops monotonically increase from 0.0 to 1.0.

The general process is:

• Ensure that the first gradient stop value is 0.0. If not, insert a new stop with a value of 0.0 and use the first gradient color as this new stops color.
• Ensure the last gradient stop value is 1.0. If not, insert a new stop with a value of 1.0 and use the last gradient color as this stops color.
• Clamp all gradient values between the values of 0.0 and 1.0.
• For all stop values, ensure that the values are monotonically increasing by clamping each value to a minimum of the previous stop value and itself. For example, with stop values of 0.0, 0.5, 0.4, 1.0, we would clamp such that the values were 0.0, 0.5, 0.5, 1.0.

Definition at line 212 of file skia_conversions.cc.

                                           {
  FML_DCHECK(gradient->stop_count() >= 2);
 
  auto* dl_colors = gradient->colors();
  auto* dl_stops = gradient->stops();
  if (dl_stops[0] != 0.0) {
    colors.emplace_back(skia_conversions::ToColor(dl_colors[0]));
    stops.emplace_back(0);
  }
  for (auto i = 0; i < gradient->stop_count(); i++) {
    colors.emplace_back(skia_conversions::ToColor(dl_colors[i]));
    stops.emplace_back(std::clamp(dl_stops[i], 0.0f, 1.0f));
  }
  if (dl_stops[gradient->stop_count() - 1] != 1.0) {
    colors.emplace_back(colors.back());
    stops.emplace_back(1.0);
  }
  for (auto i = 1; i < gradient->stop_count(); i++) {
    stops[i] = std::clamp(stops[i], stops[i - 1], stops[i]);
  }
}

References ToColor().

Referenced by impeller::DlDispatcherBase::setColorSource(), and impeller::testing::TEST().

IsNearlySimpleRRect()

bool impeller::skia_conversions::IsNearlySimpleRRect

(

const SkRRect &

rr

)

Like SkRRect.isSimple, but allows the corners to differ by kEhCloseEnough.

An RRect is simple if all corner radii are approximately equal.

Definition at line 12 of file skia_conversions.cc.

                                            {
  auto [a, b] = rr.radii(SkRRect::kUpperLeft_Corner);
  auto [c, d] = rr.radii(SkRRect::kLowerLeft_Corner);
  auto [e, f] = rr.radii(SkRRect::kUpperRight_Corner);
  auto [g, h] = rr.radii(SkRRect::kLowerRight_Corner);
  return SkScalarNearlyEqual(a, b, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, c, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, d, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, e, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, f, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, g, kEhCloseEnough) &&
         SkScalarNearlyEqual(a, h, kEhCloseEnough);
}

References impeller::saturated::b, and impeller::kEhCloseEnough.

Referenced by impeller::DlDispatcherBase::drawRRect(), and impeller::testing::TEST().

PathDataFromTextBlob()

Path impeller::skia_conversions::PathDataFromTextBlob	(	const sk_sp< SkTextBlob > &	blob,
		Point	shift
	)

Definition at line 188 of file skia_conversions.cc.

                                                                      {
  if (!blob) {
    return {};
  }
 
  return ToPath(skia::textlayout::Paragraph::GetPath(blob.get()), shift);
}

References ToPath().

ToColor()

Color impeller::skia_conversions::ToColor

(

const flutter::DlColor &

color

)

Definition at line 162 of file skia_conversions.cc.

                                           {
  return {
      static_cast<Scalar>(color.getRedF()),    //
      static_cast<Scalar>(color.getGreenF()),  //
      static_cast<Scalar>(color.getBlueF()),   //
      static_cast<Scalar>(color.getAlphaF())   //
  };
}

References color.

Referenced by ConvertStops(), impeller::DlDispatcherBase::drawColor(), impeller::DlDispatcherBase::drawShadow(), impeller::MakeVertices(), impeller::testing::TEST(), impeller::ToColorFilter(), and impeller::ToColors().

ToPath() [1/2]

Path impeller::skia_conversions::ToPath	(	const SkPath &	path,
		Point	shift
	)

Definition at line 63 of file skia_conversions.cc.

                                             {
  auto iterator = SkPath::Iter(path, false);
 
  struct PathData {
    union {
      SkPoint points[4];
    };
  };
 
  PathBuilder builder;
  PathData data;
  // Reserve a path size with some arbitrarily additional padding.
  builder.Reserve(path.countPoints() + 8, path.countVerbs() + 8);
  auto verb = SkPath::Verb::kDone_Verb;
  do {
    verb = iterator.next(data.points);
    switch (verb) {
      case SkPath::kMove_Verb:
        builder.MoveTo(ToPoint(data.points[0]));
        break;
      case SkPath::kLine_Verb:
        builder.LineTo(ToPoint(data.points[1]));
        break;
      case SkPath::kQuad_Verb:
        builder.QuadraticCurveTo(ToPoint(data.points[1]),
                                 ToPoint(data.points[2]));
        break;
      case SkPath::kConic_Verb: {
        constexpr auto kPow2 = 1;  // Only works for sweeps up to 90 degrees.
        constexpr auto kQuadCount = 1 + (2 * (1 << kPow2));
        SkPoint points[kQuadCount];
        const auto curve_count =
            SkPath::ConvertConicToQuads(data.points[0],          //
                                        data.points[1],          //
                                        data.points[2],          //
                                        iterator.conicWeight(),  //
                                        points,                  //
                                        kPow2                    //
            );
 
        for (int curve_index = 0, point_index = 0;  //
             curve_index < curve_count;             //
             curve_index++, point_index += 2        //
        ) {
          builder.QuadraticCurveTo(ToPoint(points[point_index + 1]),
                                   ToPoint(points[point_index + 2]));
        }
      } break;
      case SkPath::kCubic_Verb:
        builder.CubicCurveTo(ToPoint(data.points[1]), ToPoint(data.points[2]),
                             ToPoint(data.points[3]));
        break;
      case SkPath::kClose_Verb:
        builder.Close();
        break;
      case SkPath::kDone_Verb:
        break;
    }
  } while (verb != SkPath::Verb::kDone_Verb);
 
  FillType fill_type;
  switch (path.getFillType()) {
    case SkPathFillType::kWinding:
      fill_type = FillType::kNonZero;
      break;
    case SkPathFillType::kEvenOdd:
      fill_type = FillType::kOdd;
      break;
    case SkPathFillType::kInverseWinding:
    case SkPathFillType::kInverseEvenOdd:
      // Flutter doesn't expose these path fill types. These are only visible
      // via the receiver interface. We should never get here.
      fill_type = FillType::kNonZero;
      break;
  }
  builder.SetConvexity(path.isConvex() ? Convexity::kConvex
                                       : Convexity::kUnknown);
  builder.Shift(shift);
  auto sk_bounds = path.getBounds().makeOutset(shift.x, shift.y);
  builder.SetBounds(ToRect(sk_bounds));
  return builder.TakePath(fill_type);
}

References impeller::PathBuilder::Close(), impeller::PathBuilder::CubicCurveTo(), data, impeller::kConvex, impeller::kNonZero, impeller::kOdd, impeller::kUnknown, impeller::PathBuilder::LineTo(), impeller::PathBuilder::MoveTo(), impeller::PathBuilder::QuadraticCurveTo(), impeller::PathBuilder::Reserve(), impeller::PathBuilder::SetBounds(), impeller::PathBuilder::SetConvexity(), impeller::PathBuilder::Shift(), impeller::PathBuilder::TakePath(), ToPoint(), ToRect(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::DlDispatcherBase::clipRRect(), impeller::DlDispatcherBase::drawDRRect(), impeller::DlDispatcherBase::drawRRect(), and PathDataFromTextBlob().

ToPath() [2/2]

Path impeller::skia_conversions::ToPath

(

const SkRRect &

rrect

)

Definition at line 146 of file skia_conversions.cc.

                                  {
  return PathBuilder{}
      .AddRoundedRect(ToRect(rrect.getBounds()), ToRoundingRadii(rrect))
      .SetConvexity(Convexity::kConvex)
      .SetBounds(ToRect(rrect.getBounds()))
      .TakePath();
}

References impeller::PathBuilder::AddRoundedRect(), impeller::kConvex, impeller::PathBuilder::SetBounds(), impeller::PathBuilder::SetConvexity(), impeller::PathBuilder::TakePath(), ToRect(), and ToRoundingRadii().

ToPixelFormat()

std::optional< impeller::PixelFormat > impeller::skia_conversions::ToPixelFormat

(

SkColorType

type

)

Definition at line 196 of file skia_conversions.cc.

                                                                 {
  switch (type) {
    case kRGBA_8888_SkColorType:
      return impeller::PixelFormat::kR8G8B8A8UNormInt;
    case kBGRA_8888_SkColorType:
      return impeller::PixelFormat::kB8G8R8A8UNormInt;
    case kRGBA_F16_SkColorType:
      return impeller::PixelFormat::kR16G16B16A16Float;
    case kBGR_101010x_XR_SkColorType:
      return impeller::PixelFormat::kB10G10R10XR;
    default:
      return std::nullopt;
  }
  return std::nullopt;
}

References impeller::kB10G10R10XR, impeller::kB8G8R8A8UNormInt, impeller::kR16G16B16A16Float, impeller::kR8G8B8A8UNormInt, and type.

ToPoint()

Point impeller::skia_conversions::ToPoint

(

const SkPoint &

point

)

Definition at line 154 of file skia_conversions.cc.

                                    {
  return Point::MakeXY(point.fX, point.fY);
}

References impeller::TPoint< Scalar >::MakeXY().

Referenced by impeller::DlDispatcherBase::drawCircle(), impeller::DlDispatcherBase::drawLine(), impeller::DlDispatcherBase::drawPoints(), impeller::MakeVertices(), impeller::DlDispatcherBase::setColorSource(), impeller::testing::TEST(), ToPath(), ToPoints(), and ToRoundingRadii().

ToPoints()

std::vector< Point > impeller::skia_conversions::ToPoints	(	const SkPoint	points[],
		int	count
	)

Definition at line 45 of file skia_conversions.cc.

                                                             {
  std::vector<Point> result(count);
  for (auto i = 0; i < count; i++) {
    result[i] = ToPoint(points[i]);
  }
  return result;
}

References ToPoint().

Referenced by impeller::DlDispatcherBase::drawPoints().

ToRect() [1/2]

Rect impeller::skia_conversions::ToRect

(

const SkRect &

rect

)

Definition at line 26 of file skia_conversions.cc.

                                {
  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}

References impeller::TRect< Scalar >::MakeLTRB().

Referenced by impeller::DlDispatcherBase::clipPath(), impeller::DlDispatcherBase::clipRect(), impeller::DlDispatcherBase::clipRRect(), impeller::DlDispatcherBase::drawArc(), impeller::DlDispatcherBase::drawAtlas(), impeller::DlDispatcherBase::drawDisplayList(), impeller::DlDispatcherBase::drawImageNine(), impeller::DlDispatcherBase::drawImageRect(), impeller::DlDispatcherBase::drawOval(), impeller::DlDispatcherBase::drawRect(), impeller::DlDispatcherBase::drawRRect(), impeller::DlDispatcherBase::saveLayer(), ToPath(), and ToRects().

ToRect() [2/2]

std::optional< Rect > impeller::skia_conversions::ToRect

(

const SkRect *

rect

)

Definition at line 30 of file skia_conversions.cc.

                                             {
  if (rect == nullptr) {
    return std::nullopt;
  }
  return Rect::MakeLTRB(rect->fLeft, rect->fTop, rect->fRight, rect->fBottom);
}

References impeller::TRect< Scalar >::MakeLTRB().

ToRects()

std::vector< Rect > impeller::skia_conversions::ToRects	(	const SkRect	tex[],
		int	count
	)

Definition at line 37 of file skia_conversions.cc.

                                                       {
  auto result = std::vector<Rect>();
  for (int i = 0; i < count; i++) {
    result.push_back(ToRect(tex[i]));
  }
  return result;
}

References ToRect().

Referenced by impeller::DlDispatcherBase::drawAtlas().

ToRoundingRadii()

PathBuilder::RoundingRadii impeller::skia_conversions::ToRoundingRadii

(

const SkRRect &

rrect

)

Definition at line 53 of file skia_conversions.cc.

                                                               {
  using Corner = SkRRect::Corner;
  PathBuilder::RoundingRadii radii;
  radii.bottom_left = ToPoint(rrect.radii(Corner::kLowerLeft_Corner));
  radii.bottom_right = ToPoint(rrect.radii(Corner::kLowerRight_Corner));
  radii.top_left = ToPoint(rrect.radii(Corner::kUpperLeft_Corner));
  radii.top_right = ToPoint(rrect.radii(Corner::kUpperRight_Corner));
  return radii;
}

References impeller::PathBuilder::RoundingRadii::bottom_left, impeller::PathBuilder::RoundingRadii::bottom_right, impeller::PathBuilder::RoundingRadii::top_left, impeller::PathBuilder::RoundingRadii::top_right, and ToPoint().

Referenced by ToPath().

ToRSXForms()

std::vector< Matrix > impeller::skia_conversions::ToRSXForms	(	const SkRSXform	xform[],
		int	count
	)

Definition at line 171 of file skia_conversions.cc.

                                                                 {
  auto result = std::vector<Matrix>();
  for (int i = 0; i < count; i++) {
    auto form = xform[i];
    // clang-format off
    auto matrix = Matrix{
      form.fSCos, form.fSSin, 0, 0,
     -form.fSSin, form.fSCos, 0, 0,
      0,          0,          1, 0,
      form.fTx,   form.fTy,   0, 1
    };
    // clang-format on
    result.push_back(matrix);
  }
  return result;
}

Referenced by impeller::DlDispatcherBase::drawAtlas().

ToSize()

Size impeller::skia_conversions::ToSize

(

const SkPoint &

point

)

Definition at line 158 of file skia_conversions.cc.

                                  {
  return Size(point.fX, point.fY);
}

Referenced by impeller::DlDispatcherBase::clipPath(), impeller::DlDispatcherBase::clipRRect(), impeller::DlDispatcherBase::drawRRect(), and impeller::testing::TEST().