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]);
  }
}

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);
}

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);
}

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())   //
  };
}

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);
}

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();
}

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;
}

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);
}

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;
}

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);
}

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);
}

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;
}

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;
}

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;
}

ToSize()

Size impeller::skia_conversions::ToSize

(

const SkPoint &

point

)

Definition at line 158 of file skia_conversions.cc.

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