static inline bool is_cubic_nearly_quadratic(const Sk2f& p0, const Sk2f& p1, const Sk2f& p2,
const Sk2f& p3, const Sk2f& tan0, const Sk2f& tan1,
Sk2f* c) {
Sk2f c1 = SkNx_fma(Sk2f(1.5f), tan0, p0);
Sk2f c2 = SkNx_fma(Sk2f(-1.5f), tan1, p3);
*c = (c1 + c2) * .5f; // Hopefully optimized out if not used?
return ((c1 - c2).abs() <= 1).allTrue();
}
void GrCCPathParser::parsePath(const SkMatrix& m, const SkPath& path, SkRect* devBounds,
SkRect* devBounds45) {
const SkPoint* pts = SkPathPriv::PointData(path);
int numPts = path.countPoints();
SkASSERT(numPts + 1 <= fLocalDevPtsBuffer.count());
if (!numPts) {
devBounds->setEmpty();
devBounds45->setEmpty();
this->parsePath(path, nullptr);
return;
}
// m45 transforms path points into "45 degree" device space. A bounding box in this space gives
// the circumscribing octagon's diagonals. We could use SK_ScalarRoot2Over2, but an orthonormal
// transform is not necessary as long as the shader uses the correct inverse.
SkMatrix m45;
m45.setSinCos(1, 1);
m45.preConcat(m);
// X,Y,T are two parallel view matrices that accumulate two bounding boxes as they map points:
// device-space bounds and "45 degree" device-space bounds (| 1 -1 | * devCoords).
// | 1 1 |
Sk4f X = Sk4f(m.getScaleX(), m.getSkewY(), m45.getScaleX(), m45.getSkewY());
Sk4f Y = Sk4f(m.getSkewX(), m.getScaleY(), m45.getSkewX(), m45.getScaleY());
Sk4f T = Sk4f(m.getTranslateX(), m.getTranslateY(), m45.getTranslateX(), m45.getTranslateY());
// Map the path's points to device space and accumulate bounding boxes.
Sk4f devPt = SkNx_fma(Y, Sk4f(pts[0].y()), T);
devPt = SkNx_fma(X, Sk4f(pts[0].x()), devPt);
Sk4f topLeft = devPt;
Sk4f bottomRight = devPt;
// Store all 4 values [dev.x, dev.y, dev45.x, dev45.y]. We are only interested in the first two,
// and will overwrite [dev45.x, dev45.y] with the next point. This is why the dst buffer must
// be at least one larger than the number of points.
devPt.store(&fLocalDevPtsBuffer[0]);
for (int i = 1; i < numPts; ++i) {
devPt = SkNx_fma(Y, Sk4f(pts[i].y()), T);
devPt = SkNx_fma(X, Sk4f(pts[i].x()), devPt);
topLeft = Sk4f::Min(topLeft, devPt);
bottomRight = Sk4f::Max(bottomRight, devPt);
devPt.store(&fLocalDevPtsBuffer[i]);
}
SkPoint topLeftPts[2], bottomRightPts[2];
topLeft.store(topLeftPts);
bottomRight.store(bottomRightPts);
devBounds->setLTRB(topLeftPts[0].x(), topLeftPts[0].y(), bottomRightPts[0].x(),
bottomRightPts[0].y());
devBounds45->setLTRB(topLeftPts[1].x(), topLeftPts[1].y(), bottomRightPts[1].x(),
bottomRightPts[1].y());
this->parsePath(path, fLocalDevPtsBuffer.get());
}
inline void GrCCFillGeometry::appendQuadratics(const Sk2f& p0, const Sk2f& p1, const Sk2f& p2) {
Sk2f tan0 = p1 - p0;
Sk2f tan1 = p2 - p1;
// This should almost always be this case for well-behaved curves in the real world.
if (is_convex_curve_monotonic(p0, tan0, p2, tan1)) {
this->appendMonotonicQuadratic(p0, p1, p2);
return;
}
// Chop the curve into two segments with equal curvature. To do this we find the T value whose
// tangent angle is halfway between tan0 and tan1.
Sk2f n = normalize(tan0) - normalize(tan1);
// The midtangent can be found where (dQ(t) dot n) = 0:
//
// 0 = (dQ(t) dot n) = | 2*t 1 | * | p0 - 2*p1 + p2 | * | n |
// | -2*p0 + 2*p1 | | . |
//
// = | 2*t 1 | * | tan1 - tan0 | * | n |
// | 2*tan0 | | . |
//
// = 2*t * ((tan1 - tan0) dot n) + (2*tan0 dot n)
//
// t = (tan0 dot n) / ((tan0 - tan1) dot n)
Sk2f dQ1n = (tan0 - tan1) * n;
Sk2f dQ0n = tan0 * n;
Sk2f t = (dQ0n + SkNx_shuffle<1,0>(dQ0n)) / (dQ1n + SkNx_shuffle<1,0>(dQ1n));
t = Sk2f::Min(Sk2f::Max(t, 0), 1); // Clamp for FP error.
Sk2f p01 = SkNx_fma(t, tan0, p0);
Sk2f p12 = SkNx_fma(t, tan1, p1);
Sk2f p012 = lerp(p01, p12, t);
this->appendMonotonicQuadratic(p0, p01, p012);
this->appendMonotonicQuadratic(p012, p12, p2);
}
void GrCCFillGeometry::cubicTo(const SkPoint P[4], float inflectPad, float loopIntersectPad) {
SkASSERT(fBuildingContour);
SkASSERT(P[0] == fPoints.back());
// Don't crunch on the curve or inflate geometry if it is nearly flat (or just very small).
// Flat curves can break the math below.
if (are_collinear(P)) {
Sk2f p0 = Sk2f::Load(P);
Sk2f p3 = Sk2f::Load(P+3);
this->appendLine(p0, p3);
return;
}
Sk2f p0 = Sk2f::Load(P);
Sk2f p1 = Sk2f::Load(P+1);
Sk2f p2 = Sk2f::Load(P+2);
Sk2f p3 = Sk2f::Load(P+3);
// Also detect near-quadratics ahead of time.
Sk2f tan0, tan1, c;
get_cubic_tangents(p0, p1, p2, p3, &tan0, &tan1);
if (is_cubic_nearly_quadratic(p0, p1, p2, p3, tan0, tan1, &c)) {
this->appendQuadratics(p0, c, p3);
return;
}
double tt[2], ss[2], D[4];
fCurrCubicType = SkClassifyCubic(P, tt, ss, D);
SkASSERT(!SkCubicIsDegenerate(fCurrCubicType));
Sk2f t = Sk2f(static_cast<float>(tt[0]), static_cast<float>(tt[1]));
Sk2f s = Sk2f(static_cast<float>(ss[0]), static_cast<float>(ss[1]));
ExcludedTerm skipTerm = (std::abs(D[2]) > std::abs(D[1]))
? ExcludedTerm::kQuadraticTerm
: ExcludedTerm::kLinearTerm;
Sk2f C0 = SkNx_fma(Sk2f(3), p1 - p2, p3 - p0);
Sk2f C1 = (ExcludedTerm::kLinearTerm == skipTerm
? SkNx_fma(Sk2f(-2), p1, p0 + p2)
: p1 - p0) * 3;
Sk2f C0x1 = C0 * SkNx_shuffle<1,0>(C1);
float Cdet = C0x1[0] - C0x1[1];
SkSTArray<4, float> chops;
if (SkCubicType::kLoop != fCurrCubicType) {
find_chops_around_inflection_points(inflectPad, t, s, C0, C1, skipTerm, Cdet, &chops);
} else {
find_chops_around_loop_intersection(loopIntersectPad, t, s, C0, C1, skipTerm, Cdet, &chops);
}
if (4 == chops.count() && chops[1] >= chops[2]) {
// This just the means the KLM roots are so close that their paddings overlap. We will
// approximate the entire middle section, but still have it chopped midway. For loops this
// chop guarantees the append code only sees convex segments. Otherwise, it means we are (at
// least almost) a cusp and the chop makes sure we get a sharp point.
Sk2f ts = t * SkNx_shuffle<1,0>(s);
chops[1] = chops[2] = (ts[0] + ts[1]) / (2*s[0]*s[1]);
}
#ifdef SK_DEBUG
for (int i = 1; i < chops.count(); ++i) {
SkASSERT(chops[i] >= chops[i - 1]);
}
#endif
this->appendCubics(AppendCubicMode::kLiteral, p0, p1, p2, p3, chops.begin(), chops.count());
}
// Finds where to chop a non-loop around its intersection point. The resulting cubic segments will
// be chopped such that a box of radius 'padRadius', centered at any point along the curve segment,
// is guaranteed to not cross the tangent lines at the intersection point (a.k.a lines L & M).
//
// 'chops' will be filled with 0, 2, or 4 T values. The segments between T0..T1 and T2..T3 must be
// drawn with quadratic splines instead of cubics.
//
// A loop intersection falls at two different T values, so this method takes Sk2f and computes the
// padding for both in SIMD.
static inline void find_chops_around_loop_intersection(float padRadius, Sk2f t2, Sk2f s2,
const Sk2f& C0, const Sk2f& C1,
ExcludedTerm skipTerm, float Cdet,
SkSTArray<4, float>* chops) {
SkASSERT(chops->empty());
SkASSERT(padRadius >= 0);
padRadius /= std::abs(Cdet); // Scale this single value rather than all of C^-1 later on.
// The parametric functions for distance from lines L & M are:
//
// l(T) = (T - Td)^2 * (T - Te)
// m(T) = (T - Td) * (T - Te)^2
//
// See "Resolution Independent Curve Rendering using Programmable Graphics Hardware",
// 4.3 Finding klmn:
//
// https://www.microsoft.com/en-us/research/wp-content/uploads/2005/01/p1000-loop.pdf
Sk2f T2 = t2/s2; // T2 is the double root of l(T).
Sk2f T1 = SkNx_shuffle<1,0>(T2); // T1 is the other root of l(T).
// Convert l(T), m(T) to power-basis form:
//
// | 1 1 |
// |l(T) m(T)| = |T^3 T^2 T 1| * | l2 m2 |
// | l1 m1 |
// | l0 m0 |
//
// From here on we use Sk2f with "L" names, but the second lane will be for line M.
Sk2f l2 = SkNx_fma(Sk2f(-2), T2, -T1);
Sk2f l1 = T2 * SkNx_fma(Sk2f(2), T1, T2);
Sk2f l0 = -T2*T2*T1;
// The equation for line L can be found as follows:
//
// L = C^-1 * (l excluding skipTerm)
//
// (See comments for GrPathUtils::calcCubicInverseTransposePowerBasisMatrix.)
// We are only interested in the normal to L, so only need the upper 2x2 of C^-1. And rather
// than divide by determinant(C) here, we have already performed this divide on padRadius.
Sk2f l2or1 = (ExcludedTerm::kLinearTerm == skipTerm) ? l2 : l1;
Sk2f Lx = -C0[1]*l2or1 + C1[1]; // l3 is always 1.
Sk2f Ly = C0[0]*l2or1 - C1[0];
// A box of radius "padRadius" is touching line L if "center dot L" is less than the Manhattan
// with of L. (See rationale in are_collinear.)
Sk2f Lwidth = Lx.abs() + Ly.abs();
Sk2f pad = Lwidth * padRadius;
// Is l(T=0) outside the padding around line L?
Sk2f lT0 = l0; // l(T=0) = |0 0 0 1| dot |1 l2 l1 l0| = l0
Sk2f outsideT0 = lT0.abs() - pad;
// Is l(T=1) outside the padding around line L?
Sk2f lT1 = (Sk2f(1) + l2 + l1 + l0).abs(); // l(T=1) = |1 1 1 1| dot |1 l2 l1 l0|
Sk2f outsideT1 = lT1.abs() - pad;
// Values for solving the cubic.
Sk2f p, q, qqq, discr, numRoots, D;
bool hasDiscr = false;
// Values for calculating one root (rarely needed).
Sk2f R, QQ;
bool hasOneRootVals = false;
// Values for calculating three roots.
Sk2f P, cosTheta3;
bool hasThreeRootVals = false;
// Solve for the T values where l(T) = +pad and m(T) = -pad.
for (int i = 0; i < 2; ++i) {
float T = T2[i]; // T is the point we are chopping around.
if ((T < 0 && outsideT0[i] >= 0) || (T > 1 && outsideT1[i] >= 0)) {
// The padding around T is completely out of range. No point solving for it.
continue;
}
if (!hasDiscr) {
p = Sk2f(+.5f, -.5f) * pad;
q = (1.f/3) * (T2 - T1);
qqq = q*q*q;
discr = qqq*p*2 + p*p;
numRoots = (discr < 0).thenElse(3, 1);
D = T2 - q;
hasDiscr = true;
}
if (1 == numRoots[i]) {
if (!hasOneRootVals) {
Sk2f r = qqq + p;
Sk2f s = r.abs() + discr.sqrt();
R = (r > 0).thenElse(-s, s);
QQ = q*q;
hasOneRootVals = true;
}
float A = cbrtf(R[i]);
float B = A != 0 ? QQ[i]/A : 0;
// When there is only one root, ine L chops from root..1, line M chops from 0..root.
if (1 == i) {
chops->push_back(0);
}
chops->push_back(A + B + D[i]);
if (0 == i) {
chops->push_back(1);
}
continue;
}
if (!hasThreeRootVals) {
P = q.abs() * -2;
cosTheta3 = (q >= 0).thenElse(1, -1) + p / qqq.abs();
hasThreeRootVals = true;
}
static constexpr float k2PiOver3 = 2 * SK_ScalarPI / 3;
float theta = std::acos(cosTheta3[i]) * (1.f/3);
float roots[3] = {P[i] * std::cos(theta) + D[i],
P[i] * std::cos(theta + k2PiOver3) + D[i],
P[i] * std::cos(theta - k2PiOver3) + D[i]};
// Sort the three roots.
swap_if_greater(roots[0], roots[1]);
swap_if_greater(roots[1], roots[2]);
swap_if_greater(roots[0], roots[1]);
// Line L chops around the first 2 roots, line M chops around the second 2.
chops->push_back_n(2, &roots[i]);
}
}
template<int N> static inline SkNx<N,float> lerp(const SkNx<N,float>& a, const SkNx<N,float>& b,
const SkNx<N,float>& t) {
return SkNx_fma(t, b - a, a);
}
