void GrTextBlob::flush(GrTextTarget* target, const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable, const SkPaint& paint, GrColor filteredColor, const GrClip& clip, const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { // GrTextBlob::makeOp only takes uint16_t values for run and subRun indices. // Encountering something larger than this is highly unlikely, so we'll just not draw it. int lastRun = SkTMin(fRunCount, (1 << 16)) - 1; // For each run in the GrTextBlob we're going to churn through all the glyphs. // Each run is broken into a path part and a Mask / DFT / ARGB part. for (int runIndex = 0; runIndex <= lastRun; runIndex++) { Run& run = fRuns[runIndex]; // first flush any path glyphs if (run.fPathGlyphs.count()) { SkPaint runPaint{paint}; runPaint.setFlags((runPaint.getFlags() & ~Run::kPaintFlagsMask) | run.fPaintFlags); for (int i = 0; i < run.fPathGlyphs.count(); i++) { GrTextBlob::Run::PathGlyph& pathGlyph = run.fPathGlyphs[i]; SkMatrix ctm; const SkPath* path = &pathGlyph.fPath; // TmpPath must be in the same scope as GrShape shape below. SkTLazy<SkPath> tmpPath; // The glyph positions and glyph outlines are either in device space or in source // space based on fPreTransformed. if (!pathGlyph.fPreTransformed) { // Positions and outlines are in source space. ctm = viewMatrix; SkMatrix pathMatrix = SkMatrix::MakeScale(pathGlyph.fScale, pathGlyph.fScale); // The origin for the blob may have changed, so figure out the delta. SkVector originShift = SkPoint{x, y} - SkPoint{fInitialX, fInitialY}; // Shift the original glyph location in source space to the position of the new // blob. pathMatrix.postTranslate(originShift.x() + pathGlyph.fX, originShift.y() + pathGlyph.fY); // If there are shaders, blurs or styles, the path must be scaled into source // space independently of the CTM. This allows the CTM to be correct for the // different effects. GrStyle style(runPaint); bool scalePath = runPaint.getShader() || style.applies() || runPaint.getMaskFilter(); if (!scalePath) { // Scale can be applied to CTM -- no effects. ctm.preConcat(pathMatrix); } else { // Scale the outline into source space. // Transform the path form the normalized outline to source space. This // way the CTM will remain the same so it can be used by the effects. SkPath* sourceOutline = tmpPath.init(); path->transform(pathMatrix, sourceOutline); sourceOutline->setIsVolatile(true); path = sourceOutline; } } else { // Positions and outlines are in device space. SkPoint originalOrigin = {fInitialX, fInitialY}; fInitialViewMatrix.mapPoints(&originalOrigin, 1); SkPoint newOrigin = {x, y}; viewMatrix.mapPoints(&newOrigin, 1); // The origin shift in device space. SkPoint originShift = newOrigin - originalOrigin; // Shift the original glyph location in device space to the position of the // new blob. ctm = SkMatrix::MakeTrans(originShift.x() + pathGlyph.fX, originShift.y() + pathGlyph.fY); } // TODO: we are losing the mutability of the path here GrShape shape(*path, paint); target->drawShape(clip, runPaint, ctm, shape); } } // then flush each subrun, if any if (!run.fInitialized) { continue; } int lastSubRun = SkTMin(run.fSubRunInfo.count(), 1 << 16) - 1; for (int subRun = 0; subRun <= lastSubRun; subRun++) { const Run::SubRunInfo& info = run.fSubRunInfo[subRun]; int glyphCount = info.glyphCount(); if (0 == glyphCount) { continue; } bool skipClip = false; bool submitOp = true; SkIRect clipRect = SkIRect::MakeEmpty(); SkRect rtBounds = SkRect::MakeWH(target->width(), target->height()); SkRRect clipRRect; GrAA aa; // We can clip geometrically if we're not using SDFs or transformed glyphs, // and we have an axis-aligned rectangular non-AA clip if (!info.drawAsDistanceFields() && !info.needsTransform() && clip.isRRect(rtBounds, &clipRRect, &aa) && clipRRect.isRect() && GrAA::kNo == aa) { skipClip = true; // We only need to do clipping work if the subrun isn't contained by the clip SkRect subRunBounds; this->computeSubRunBounds(&subRunBounds, runIndex, subRun, viewMatrix, x, y, false); if (!clipRRect.getBounds().contains(subRunBounds)) { // If the subrun is completely outside, don't add an op for it if (!clipRRect.getBounds().intersects(subRunBounds)) { submitOp = false; } else { clipRRect.getBounds().round(&clipRect); } } } if (submitOp) { auto op = this->makeOp(info, glyphCount, runIndex, subRun, viewMatrix, x, y, clipRect, paint, filteredColor, props, distanceAdjustTable, target); if (op) { if (skipClip) { target->addDrawOp(GrNoClip(), std::move(op)); } else { target->addDrawOp(clip, std::move(op)); } } } } } }