From 0ab5ce151c4507966c135ab3986cf2b28b36d6c6 Mon Sep 17 00:00:00 2001 From: Herb Derby Date: Mon, 30 Jul 2018 10:10:40 -0400 Subject: Move path leaf loop to drawer This CL makes GPU and Raster use the same path drawing interface. When I get the main body of regenerate over into the glyph run system, I I can refactor a lot of annoyingly similar code away. Change-Id: I6bd2e6119570062695d6943565749d85555b03fa Reviewed-on: https://skia-review.googlesource.com/144350 Reviewed-by: Jim Van Verth Commit-Queue: Herb Derby --- src/core/SkDraw.cpp | 15 ++++++++++--- src/core/SkGlyphRun.cpp | 48 +++++++++++++++++------------------------- src/core/SkGlyphRun.h | 10 ++++----- src/gpu/text/GrTextContext.cpp | 25 +++++++++++----------- 4 files changed, 48 insertions(+), 50 deletions(-) diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp index b35d7f9f4c..177d38f535 100644 --- a/src/core/SkDraw.cpp +++ b/src/core/SkDraw.cpp @@ -1628,9 +1628,18 @@ void SkDraw::drawGlyphRunList( return; } - auto perPathBuilder = [this](const SkPaint& paint, SkArenaAlloc*) { - auto perPath = [this, &paint](const SkPath& path, const SkMatrix& matrix) { - this->drawPath(path, paint, &matrix, false); + SkMatrix renderMatrix{*fMatrix}; + auto perPathBuilder = [this, &renderMatrix] + (const SkPaint& paint, SkScalar scaleMatrix, SkArenaAlloc*) { + renderMatrix.setScale(scaleMatrix, scaleMatrix); + auto perPath = + [this, &renderMatrix, &paint] + (const SkPath* path, const SkGlyph&, SkPoint position) { + if (path != nullptr) { + renderMatrix[SkMatrix::kMTransX] = position.fX; + renderMatrix[SkMatrix::kMTransY] = position.fY; + this->drawPath(*path, paint, &renderMatrix, false); + } }; return perPath; }; diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp index 1a24c3bdb9..7bb452a449 100644 --- a/src/core/SkGlyphRun.cpp +++ b/src/core/SkGlyphRun.cpp @@ -163,38 +163,16 @@ bool SkGlyphRunListDrawer::ensureBitmapBuffers(size_t runSize) { } void SkGlyphRunListDrawer::drawUsingPaths( - const SkGlyphRun& glyphRun, SkPoint origin, - const SkSurfaceProps& props, PerPath perPath) const { - // setup our std paint, in hopes of getting hits in the cache - const SkPaint& origPaint = glyphRun.paint(); - SkPaint paint(glyphRun.paint()); - SkScalar matrixScale = paint.setupForAsPaths(); + const SkGlyphRun& glyphRun, SkPoint origin, SkGlyphCache* cache, PerPath perPath) const { - SkMatrix matrix; - matrix.setScale(matrixScale, matrixScale); - - // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache. - paint.setStyle(SkPaint::kFill_Style); - paint.setPathEffect(nullptr); - - auto cache = SkStrikeCache::FindOrCreateStrikeExclusive( - paint, &props, fScalerContextFlags, nullptr); - - // Now restore the original settings, so we "draw" with whatever style/stroking. - paint.setStyle(origPaint.getStyle()); - paint.setPathEffect(origPaint.refPathEffect()); - - auto eachGlyph = [perPath{std::move(perPath)}, origin, &cache, &matrix] + auto eachGlyph = + [perPath{std::move(perPath)}, origin, &cache] (SkGlyphID glyphID, SkPoint position) { const SkGlyph& glyph = cache->getGlyphIDMetrics(glyphID); if (glyph.fWidth > 0) { const SkPath* path = cache->findPath(glyph); - if (path != nullptr) { - SkPoint loc = position + origin; - matrix[SkMatrix::kMTransX] = loc.fX; - matrix[SkMatrix::kMTransY] = loc.fY; - perPath(*path, matrix); - } + SkPoint loc = position + origin; + perPath(path, glyph, loc); } }; @@ -319,8 +297,20 @@ void SkGlyphRunListDrawer::drawForBitmapDevice( : fBitmapFallbackProps; auto paint = glyphRun.paint(); if (ShouldDrawAsPath(glyphRun.paint(), deviceMatrix)) { - auto perPath = perPathCreator(paint, &alloc); - this->drawUsingPaths(glyphRun, origin, props, perPath); + + // setup our std pathPaint, in hopes of getting hits in the cache + SkPaint pathPaint(glyphRun.paint()); + SkScalar matrixScale = pathPaint.setupForAsPaths(); + + // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache. + pathPaint.setStyle(SkPaint::kFill_Style); + pathPaint.setPathEffect(nullptr); + + auto pathCache = SkStrikeCache::FindOrCreateStrikeExclusive( + pathPaint, &props, fScalerContextFlags, nullptr); + + auto perPath = perPathCreator(paint, matrixScale, &alloc); + this->drawUsingPaths(glyphRun, origin, pathCache.get(), perPath); } else { auto cache = SkStrikeCache::FindOrCreateStrikeExclusive( paint, &props, fScalerContextFlags, &deviceMatrix); diff --git a/src/core/SkGlyphRun.h b/src/core/SkGlyphRun.h index 6bdc633091..7f9307292c 100644 --- a/src/core/SkGlyphRun.h +++ b/src/core/SkGlyphRun.h @@ -119,21 +119,21 @@ public: using PerMask = std::function; using PerMaskCreator = std::function; - using PerPath = std::function; - using PerPathCreator = std::function; + using PerPath = std::function; + using PerPathCreator = std::function; void drawForBitmapDevice( const SkGlyphRunList& glyphRunList, const SkMatrix& deviceMatrix, PerMaskCreator perMaskCreator, PerPathCreator perPathCreator); void drawUsingMasks( SkGlyphCache* cache, const SkGlyphRun& glyphRun, SkPoint origin, const SkMatrix& deviceMatrix, PerMask perMask); + void drawUsingPaths( + const SkGlyphRun& glyphRun, SkPoint origin, SkGlyphCache* cache, PerPath perPath) const; private: static bool ShouldDrawAsPath(const SkPaint& paint, const SkMatrix& matrix); bool ensureBitmapBuffers(size_t runSize); - void drawUsingPaths( - const SkGlyphRun& glyphRun, SkPoint origin, - const SkSurfaceProps& props, PerPath perPath) const; void drawGlyphRunAsSubpixelMask( SkGlyphCache* cache, const SkGlyphRun& glyphRun, SkPoint origin, const SkMatrix& deviceMatrix, diff --git a/src/gpu/text/GrTextContext.cpp b/src/gpu/text/GrTextContext.cpp index 6017742707..966f3c2f7e 100644 --- a/src/gpu/text/GrTextContext.cpp +++ b/src/gpu/text/GrTextContext.cpp @@ -169,21 +169,20 @@ void GrTextContext::regenerateGlyphRunList(GrTextBlob* cacheBlob, auto cache = SkStrikeCache::FindOrCreateStrikeExclusive( pathPaint, &props, SkScalerContextFlags::kFakeGammaAndBoostContrast, nullptr); - const SkPoint* positionCursor = glyphRun.positions().data(); - for (auto glyphID : glyphRun.shuntGlyphsIDs()) { - const SkGlyph& glyph = cache->getGlyphIDMetrics(glyphID); - SkPoint loc = origin + *positionCursor++; - if (glyph.fWidth > 0) { - if (glyph.fMaskFormat == SkMask::kARGB32_Format) { - fallbackTextHelper.appendText(glyph, glyphID, loc); - } else { - const SkPath* path = cache->findPath(glyph); - if (path != nullptr) { - cacheBlob->appendPathGlyph(runIndex, *path, loc.fX, loc.fY, matrixScale, false); - } + auto drawOnePath = + [&fallbackTextHelper, matrixScale, runIndex, cacheBlob] + (const SkPath* path, const SkGlyph& glyph, SkPoint position) { + if (glyph.fMaskFormat == SkMask::kARGB32_Format) { + fallbackTextHelper.appendText(glyph, glyph.getGlyphID(), position); + } else { + if (path != nullptr) { + cacheBlob->appendPathGlyph( + runIndex, *path, position.fX, position.fY, matrixScale, false); } } - } + }; + + glyphDrawer->drawUsingPaths(glyphRun, origin, cache.get(), drawOnePath); fallbackTextHelper.drawText( cacheBlob, runIndex, glyphCache, props, runPaint, scalerContextFlags); -- cgit v1.2.3