FloatPoint Path::currentPoint() const
{
if (hasCurrentPoint()) {
SkPoint lastPt;
m_path->getLastPt(&lastPt);
return lastPt;
}
float quietNaN = std::numeric_limits<float>::quiet_NaN();
return FloatPoint(quietNaN, quietNaN);
}
void Path::addArc(const FloatPoint& center, float radius, float startAngle, float endAngle, bool anticlockwise)
{
// The OpenVG spec says nothing about inf as radius or start/end angle.
// WebKit seems to pass those (e.g. https://bugs.webkit.org/show_bug.cgi?id=16449),
// so abort instead of risking undefined behavior.
if (!isfinite(radius) || !isfinite(startAngle) || !isfinite(endAngle))
return;
// For some reason, the HTML 5 spec defines the angle as going clockwise
// from the positive X axis instead of going standard anticlockwise.
// So let's make it a proper angle in order to keep sanity.
startAngle = fmod((2.0 * piDouble) - startAngle, 2.0 * piDouble);
endAngle = fmod((2.0 * piDouble) - endAngle, 2.0 * piDouble);
// Make it so that endAngle > startAngle. fmod() above takes care of
// keeping the difference below 360 degrees.
if (endAngle <= startAngle)
endAngle += 2.0 * piDouble;
m_path->makeCompatibleContextCurrent();
const VGfloat angleDelta = anticlockwise
? (endAngle - startAngle)
: (startAngle - endAngle + (2.0 * piDouble));
// OpenVG uses endpoint parameterization while this method receives its
// values in center parameterization. It lacks an ellipse rotation
// parameter so we use 0 for that, and also the radius is only a single
// value which makes for rh == rv. In order to convert from endpoint to
// center parameterization, we use the formulas from the OpenVG/SVG specs:
// (x,y) = (cos rot, -sin rot; sin rot, -cos rot) * (rh * cos angle, rv * sin angle) + (center.x, center.y)
// rot is 0, which simplifies this a bit:
// (x,y) = (1, 0; 0, -1) * (rh * cos angle, rv * sin angle) + (center.x, center.y)
// = (1 * rh * cos angle + 0 * rv * sin angle, 0 * rh * cos angle + -1 * rv * sin angle) + (center.x, center.y)
// = (rh * cos angle, -rv * sin angle) + (center.x, center.y)
// (Set angle = {startAngle, endAngle} to retrieve the respective endpoints.)
const VGfloat startX = radius * cos(startAngle) + center.x();
const VGfloat startY = -radius * sin(startAngle) + center.y();
const VGfloat endX = radius * cos(endAngle) + center.x();
const VGfloat endY = -radius * sin(endAngle) + center.y();
if (angleDelta > 2.0 * piDouble - 0.05) {
VGUErrorCode error = vguEllipse(m_path->vgPath(),
center.x(), center.y(), radius * 2, radius * 2);
ASSERT(error == VGU_NO_ERROR);
} else {
// Fa: large arc flag, makes the difference between SCWARC_TO and
// LCWARC_TO, respectively SCCWARC_TO and LCCWARC_TO arcs.
const bool largeArc = (angleDelta > piDouble);
// Fs: sweep flag, specifying whether the arc is drawn in increasing
// (true) or decreasing (0) direction. No need to calculate this
// value, as it we already get it passed as a parameter
// (Fs == !anticlockwise).
// Translate the large arc and sweep flags into an OpenVG segment
// command. As OpenVG thinks of everything upside down, we need to
// reverse the anticlockwise parameter in order to get the specified
// rotation.
const VGubyte segmentCommand = !anticlockwise
? (largeArc ? VG_LCCWARC_TO_ABS : VG_SCCWARC_TO_ABS)
: (largeArc ? VG_LCWARC_TO_ABS : VG_SCWARC_TO_ABS);
// So now, we've got all the parameters in endpoint parameterization
// format as OpenVG requires it. Which means we can just pass it
// like this.
const VGubyte pathSegments[] = {
hasCurrentPoint() ? VG_LINE_TO_ABS : VG_MOVE_TO_ABS,
segmentCommand
};
const VGfloat pathData[] = {
startX, startY,
radius, radius, 0, endX, endY
};
m_path->appendPathData(2, pathSegments, pathData);
}
m_path->m_currentPoint.setX(endX);
m_path->m_currentPoint.setY(endY);
}