void GrCCFillGeometry::appendCubics(AppendCubicMode mode, const Sk2f& p0, const Sk2f& p1,
const Sk2f& p2, const Sk2f& p3, int maxSubdivisions) {
if (SkCubicType::kLoop != fCurrCubicType) {
// Serpentines and cusps are always monotonic after chopping around inflection points.
SkASSERT(!SkCubicIsDegenerate(fCurrCubicType));
if (AppendCubicMode::kApproximate == mode) {
// This section passes through an inflection point, so we can get away with a flat line.
// This can cause some curves to feel slightly more flat when inspected rigorously back
// and forth against another renderer, but for now this seems acceptable given the
// simplicity.
this->appendLine(p0, p3);
return;
}
} else {
Sk2f tan0, tan1;
get_cubic_tangents(p0, p1, p2, p3, &tan0, &tan1);
if (maxSubdivisions && !is_convex_curve_monotonic(p0, tan0, p3, tan1)) {
this->chopAndAppendCubicAtMidTangent(mode, p0, p1, p2, p3, tan0, tan1,
maxSubdivisions - 1);
return;
}
if (AppendCubicMode::kApproximate == mode) {
Sk2f c;
if (!is_cubic_nearly_quadratic(p0, p1, p2, p3, tan0, tan1, &c) && maxSubdivisions) {
this->chopAndAppendCubicAtMidTangent(mode, p0, p1, p2, p3, tan0, tan1,
maxSubdivisions - 1);
return;
}
this->appendMonotonicQuadratic(p0, c, p3);
return;
}
}
// Don't send curves to the GPU if we know they are nearly flat (or just very small).
// Since the cubic segment is known to be convex at this point, our flatness check is simple.
if (are_collinear(p0, (p1 + p2) * .5f, p3)) {
this->appendLine(p0, p3);
return;
}
SkASSERT(fPoints.back() == SkPoint::Make(p0[0], p0[1]));
SkASSERT((p0 != p3).anyTrue());
p1.store(&fPoints.push_back());
p2.store(&fPoints.push_back());
p3.store(&fPoints.push_back());
fVerbs.push_back(Verb::kMonotonicCubicTo);
++fCurrContourTallies.fCubics;
}
inline void GrCCFillGeometry::appendMonotonicQuadratic(const Sk2f& p0, const Sk2f& p1,
const Sk2f& p2) {
// Don't send curves to the GPU if we know they are nearly flat (or just very small).
if (are_collinear(p0, p1, p2)) {
this->appendLine(p0, p2);
return;
}
SkASSERT(fPoints.back() == SkPoint::Make(p0[0], p0[1]));
SkASSERT((p0 != p2).anyTrue());
p1.store(&fPoints.push_back());
p2.store(&fPoints.push_back());
fVerbs.push_back(Verb::kMonotonicQuadraticTo);
++fCurrContourTallies.fQuadratics;
}
inline void GrCCFillGeometry::appendLine(const Sk2f& p0, const Sk2f& p1) {
SkASSERT(fPoints.back() == SkPoint::Make(p0[0], p0[1]));
if ((p0 == p1).allTrue()) {
return;
}
p1.store(&fPoints.push_back());
fVerbs.push_back(Verb::kLineTo);
}
void GrCCFillGeometry::appendMonotonicConic(const Sk2f& p0, const Sk2f& p1, const Sk2f& p2,
float w) {
SkASSERT(w >= 0);
Sk2f base = p2 - p0;
Sk2f baseAbs = base.abs();
float baseWidth = baseAbs[0] + baseAbs[1];
// Find the height of the curve. Max height always occurs at T=.5 for conics.
Sk2f d = (p1 - p0) * SkNx_shuffle<1,0>(base);
float h1 = std::abs(d[1] - d[0]); // Height of p1 above the base.
float ht = h1*w, hs = 1 + w; // Height of the conic = ht/hs.
// i.e. (ht/hs <= baseWidth * kFlatnessThreshold). Use "<=" in case base == 0.
if (ht <= (baseWidth*hs) * kFlatnessThreshold) {
// We are flat. (See rationale in are_collinear.)
this->appendLine(p0, p2);
return;
}
// i.e. (w > 1 && h1 - ht/hs < baseWidth).
if (w > 1 && h1*hs - ht < baseWidth*hs) {
// If we get within 1px of p1 when w > 1, we will pick up artifacts from the implicit
// function's reflection. Chop at max height (T=.5) and draw a triangle instead.
Sk2f p1w = p1*w;
Sk2f ab = p0 + p1w;
Sk2f bc = p1w + p2;
Sk2f highpoint = (ab + bc) / (2*(1 + w));
this->appendLine(p0, highpoint);
this->appendLine(highpoint, p2);
return;
}
SkASSERT(fPoints.back() == SkPoint::Make(p0[0], p0[1]));
SkASSERT((p0 != p2).anyTrue());
p1.store(&fPoints.push_back());
p2.store(&fPoints.push_back());
fConicWeights.push_back(w);
fVerbs.push_back(Verb::kMonotonicConicTo);
++fCurrContourTallies.fConics;
}
void GrDrawVerticesOp::onPrepareDraws(Target* target) const {
bool hasColorAttribute;
bool hasLocalCoordsAttribute;
sk_sp<GrGeometryProcessor> gp = this->makeGP(&hasColorAttribute, &hasLocalCoordsAttribute);
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(SkPoint) + (hasColorAttribute ? sizeof(uint32_t) : 0) +
(hasLocalCoordsAttribute ? sizeof(SkPoint) : 0));
int instanceCount = fMeshes.count();
const GrBuffer* vertexBuffer;
int firstVertex;
void* verts = target->makeVertexSpace(vertexStride, fVertexCount, &vertexBuffer, &firstVertex);
if (!verts) {
SkDebugf("Could not allocate vertices\n");
return;
}
const GrBuffer* indexBuffer = nullptr;
int firstIndex = 0;
uint16_t* indices = nullptr;
if (this->isIndexed()) {
indices = target->makeIndexSpace(fIndexCount, &indexBuffer, &firstIndex);
if (!indices) {
SkDebugf("Could not allocate indices\n");
return;
}
}
int vertexOffset = 0;
// We have a fast case below for uploading the vertex data when the matrix is translate
// only and there are colors but not local coords.
bool fastAttrs = hasColorAttribute && !hasLocalCoordsAttribute;
for (int i = 0; i < instanceCount; i++) {
const Mesh& mesh = fMeshes[i];
if (indices) {
int indexCount = mesh.fVertices->indexCount();
for (int j = 0; j < indexCount; ++j) {
*indices++ = mesh.fVertices->indices()[j] + vertexOffset;
}
}
int vertexCount = mesh.fVertices->vertexCount();
const SkPoint* positions = mesh.fVertices->positions();
const SkColor* colors = mesh.fVertices->colors();
const SkPoint* localCoords = mesh.fVertices->texCoords();
bool fastMesh = (!this->hasMultipleViewMatrices() ||
mesh.fViewMatrix.getType() <= SkMatrix::kTranslate_Mask) &&
mesh.hasPerVertexColors();
if (fastAttrs && fastMesh) {
struct V {
SkPoint fPos;
uint32_t fColor;
};
SkASSERT(sizeof(V) == vertexStride);
V* v = (V*)verts;
Sk2f t(0, 0);
if (this->hasMultipleViewMatrices()) {
t = Sk2f(mesh.fViewMatrix.getTranslateX(), mesh.fViewMatrix.getTranslateY());
}
for (int j = 0; j < vertexCount; ++j) {
Sk2f p = Sk2f::Load(positions++) + t;
p.store(&v[j].fPos);
v[j].fColor = colors[j];
}
verts = v + vertexCount;
} else {
static constexpr size_t kColorOffset = sizeof(SkPoint);
size_t localCoordOffset =
hasColorAttribute ? kColorOffset + sizeof(uint32_t) : kColorOffset;
for (int j = 0; j < vertexCount; ++j) {
if (this->hasMultipleViewMatrices()) {
mesh.fViewMatrix.mapPoints(((SkPoint*)verts), &positions[j], 1);
} else {
*((SkPoint*)verts) = positions[j];
}
if (hasColorAttribute) {
if (mesh.hasPerVertexColors()) {
*(uint32_t*)((intptr_t)verts + kColorOffset) = colors[j];
} else {
*(uint32_t*)((intptr_t)verts + kColorOffset) = mesh.fColor;
}
}
if (hasLocalCoordsAttribute) {
if (mesh.hasExplicitLocalCoords()) {
*(SkPoint*)((intptr_t)verts + localCoordOffset) = localCoords[j];
} else {
*(SkPoint*)((intptr_t)verts + localCoordOffset) = positions[j];
}
}
verts = (void*)((intptr_t)verts + vertexStride);
}
}
vertexOffset += vertexCount;
}
GrMesh mesh(this->primitiveType());
if (!indices) {
mesh.setNonIndexedNonInstanced(fVertexCount);
} else {
mesh.setIndexed(indexBuffer, fIndexCount, firstIndex, 0, fVertexCount - 1);
}
mesh.setVertexData(vertexBuffer, firstVertex);
target->draw(gp.get(), fHelper.makePipeline(target), mesh);
}
void GrDrawVerticesOp::fillBuffers(bool hasColorAttribute,
bool hasLocalCoordsAttribute,
bool hasBoneAttribute,
size_t vertexStride,
void* verts,
uint16_t* indices) const {
int instanceCount = fMeshes.count();
// Copy data into the buffers.
int vertexOffset = 0;
// We have a fast case below for uploading the vertex data when the matrix is translate
// only and there are colors but not local coords. Fast case does not apply when there are bone
// transformations.
bool fastAttrs = hasColorAttribute && !hasLocalCoordsAttribute && !hasBoneAttribute;
for (int i = 0; i < instanceCount; i++) {
// Get each mesh.
const Mesh& mesh = fMeshes[i];
// Copy data into the index buffer.
if (indices) {
int indexCount = mesh.fVertices->indexCount();
for (int j = 0; j < indexCount; ++j) {
*indices++ = mesh.fVertices->indices()[j] + vertexOffset;
}
}
// Copy data into the vertex buffer.
int vertexCount = mesh.fVertices->vertexCount();
const SkPoint* positions = mesh.fVertices->positions();
const SkColor* colors = mesh.fVertices->colors();
const SkPoint* localCoords = mesh.fVertices->texCoords();
const SkVertices::BoneIndices* boneIndices = mesh.fVertices->boneIndices();
const SkVertices::BoneWeights* boneWeights = mesh.fVertices->boneWeights();
bool fastMesh = (!this->hasMultipleViewMatrices() ||
mesh.fViewMatrix.getType() <= SkMatrix::kTranslate_Mask) &&
mesh.hasPerVertexColors();
if (fastAttrs && fastMesh) {
// Fast case.
struct V {
SkPoint fPos;
uint32_t fColor;
};
SkASSERT(sizeof(V) == vertexStride);
V* v = (V*)verts;
Sk2f t(0, 0);
if (this->hasMultipleViewMatrices()) {
t = Sk2f(mesh.fViewMatrix.getTranslateX(), mesh.fViewMatrix.getTranslateY());
}
for (int j = 0; j < vertexCount; ++j) {
Sk2f p = Sk2f::Load(positions++) + t;
p.store(&v[j].fPos);
v[j].fColor = colors[j];
}
verts = v + vertexCount;
} else {
// Normal case.
static constexpr size_t kColorOffset = sizeof(SkPoint);
size_t offset = kColorOffset;
if (hasColorAttribute) {
offset += sizeof(uint32_t);
}
size_t localCoordOffset = offset;
if (hasLocalCoordsAttribute) {
offset += sizeof(SkPoint);
}
size_t boneIndexOffset = offset;
if (hasBoneAttribute) {
offset += 4 * sizeof(int8_t);
}
size_t boneWeightOffset = offset;
for (int j = 0; j < vertexCount; ++j) {
if (this->hasMultipleViewMatrices()) {
mesh.fViewMatrix.mapPoints(((SkPoint*)verts), &positions[j], 1);
} else {
*((SkPoint*)verts) = positions[j];
}
if (hasColorAttribute) {
if (mesh.hasPerVertexColors()) {
*(uint32_t*)((intptr_t)verts + kColorOffset) = colors[j];
} else {
*(uint32_t*)((intptr_t)verts + kColorOffset) = mesh.fColor;
}
}
if (hasLocalCoordsAttribute) {
if (mesh.hasExplicitLocalCoords()) {
*(SkPoint*)((intptr_t)verts + localCoordOffset) = localCoords[j];
} else {
*(SkPoint*)((intptr_t)verts + localCoordOffset) = positions[j];
}
}
if (hasBoneAttribute) {
const SkVertices::BoneIndices& indices = boneIndices[j];
const SkVertices::BoneWeights& weights = boneWeights[j];
for (int k = 0; k < 4; k++) {
size_t indexOffset = boneIndexOffset + sizeof(int8_t) * k;
size_t weightOffset = boneWeightOffset + sizeof(uint8_t) * k;
*(int8_t*)((intptr_t)verts + indexOffset) = indices.indices[k];
*(uint8_t*)((intptr_t)verts + weightOffset) = weights.weights[k] * 255.0f;
}
}
verts = (void*)((intptr_t)verts + vertexStride);
}
}
vertexOffset += vertexCount;
}
}
// Finds where to chop a non-loop around its inflection points. 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 inflection points (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 flat lines instead of cubics.
//
// A serpentine cubic has two inflection points, so this method takes Sk2f and computes the padding
// for both in SIMD.
static inline void find_chops_around_inflection_points(float padRadius, Sk2f tl, Sk2f sl,
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 homogeneous parametric functions for distance from lines L & M are:
//
// l(t,s) = (t*sl - s*tl)^3
// m(t,s) = (t*sm - s*tm)^3
//
// 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
//
// From here on we use Sk2f with "L" names, but the second lane will be for line M.
tl = (sl > 0).thenElse(tl, -tl); // Tl=tl/sl is the triple root of l(t,s). Normalize so s >= 0.
sl = sl.abs();
// Convert l(t,s), m(t,s) to power-basis form:
//
// | l3 m3 |
// |l(t,s) m(t,s)| = |t^3 t^2*s t*s^2 s^3| * | l2 m2 |
// | l1 m1 |
// | l0 m0 |
//
Sk2f l3 = sl*sl*sl;
Sk2f l2or1 = (ExcludedTerm::kLinearTerm == skipTerm) ? sl*sl*tl*-3 : sl*tl*tl*3;
// 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 Lx = C1[1]*l3 - C0[1]*l2or1;
Sk2f Ly = -C1[0]*l3 + C0[0]*l2or1;
// 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;
// Will T=(t + cbrt(pad))/s be greater than 0? No need to solve roots outside T=0..1.
Sk2f insideLeftPad = pad + tl*tl*tl;
// Will T=(t - cbrt(pad))/s be less than 1? No need to solve roots outside T=0..1.
Sk2f tms = tl - sl;
Sk2f insideRightPad = pad - tms*tms*tms;
// Solve for the T values where abs(l(T)) = pad.
if (insideLeftPad[0] > 0 && insideRightPad[0] > 0) {
float padT = cbrtf(pad[0]);
Sk2f pts = (tl[0] + Sk2f(-padT, +padT)) / sl[0];
pts.store(chops->push_back_n(2));
}
// Solve for the T values where abs(m(T)) = pad.
if (insideLeftPad[1] > 0 && insideRightPad[1] > 0) {
float padT = cbrtf(pad[1]);
Sk2f pts = (tl[1] + Sk2f(-padT, +padT)) / sl[1];
pts.store(chops->push_back_n(2));
}
}
