static inline bool are_collinear(const Sk2f& p0, const Sk2f& p1, const Sk2f& p2, float tolerance = kFlatnessThreshold) { Sk2f l = p2 - p0; // Line from p0 -> p2. // lwidth = Manhattan width of l. Sk2f labs = l.abs(); float lwidth = labs[0] + labs[1]; // d = |p1 - p0| dot | l.y| // |-l.x| = distance from p1 to l. Sk2f dd = (p1 - p0) * SkNx_shuffle<1,0>(l); float d = dd[0] - dd[1]; // We are collinear if a box with radius "tolerance", centered on p1, touches the line l. // To decide this, we check if the distance from p1 to the line is less than the distance from // p1 to the far corner of this imaginary box, along that same normal vector. // The far corner of the box can be found at "p1 + sign(n) * tolerance", where n is normal to l: // // abs(dot(p1 - p0, n)) <= dot(sign(n) * tolerance, n) // // Which reduces to: // // abs(d) <= (n.x * sign(n.x) + n.y * sign(n.y)) * tolerance // abs(d) <= (abs(n.x) + abs(n.y)) * tolerance // // Use "<=" in case l == 0. return std::abs(d) <= lwidth * tolerance; }
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; }
GrCCPathCache::MaskTransform::MaskTransform(const SkMatrix& m, SkIVector* shift) : fMatrix2x2{m.getScaleX(), m.getSkewX(), m.getSkewY(), m.getScaleY()} { SkASSERT(!m.hasPerspective()); Sk2f translate = Sk2f(m.getTranslateX(), m.getTranslateY()); Sk2f transFloor; #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK // On Android framework we pre-round view matrix translates to integers for better caching. transFloor = translate; #else transFloor = translate.floor(); (translate - transFloor).store(fSubpixelTranslate); #endif shift->set((int)transFloor[0], (int)transFloor[1]); SkASSERT((float)shift->fX == transFloor[0]); // Make sure transFloor had integer values. SkASSERT((float)shift->fY == transFloor[1]); }
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 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]); } }
// 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)); } }