diff options
author | Herb Derby <herb@google.com> | 2018-05-24 16:12:31 -0400 |
---|---|---|
committer | Skia Commit-Bot <skia-commit-bot@chromium.org> | 2018-05-29 17:52:16 +0000 |
commit | 862405921bdbf599bac3bd829e9d6a81a4ee4d37 (patch) | |
tree | 01571847d8167751642601c4e147e8cf2ec1e4a5 /src/gpu/text/GrTextBlob.cpp | |
parent | bfb2a05af105f452a0f369e39dae05f9224dfa19 (diff) |
Rename GrAtlasTextBlob -> GrTextBlob
Change-Id: I61311b48f206890dfd1a20796d7d678cd05ef5a3
Reviewed-on: https://skia-review.googlesource.com/130140
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Herb Derby <herb@google.com>
Diffstat (limited to 'src/gpu/text/GrTextBlob.cpp')
-rw-r--r-- | src/gpu/text/GrTextBlob.cpp | 487 |
1 files changed, 487 insertions, 0 deletions
diff --git a/src/gpu/text/GrTextBlob.cpp b/src/gpu/text/GrTextBlob.cpp new file mode 100644 index 0000000000..c3d06e81fd --- /dev/null +++ b/src/gpu/text/GrTextBlob.cpp @@ -0,0 +1,487 @@ +/* + * Copyright 2015 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "GrTextBlob.h" +#include "GrBlurUtils.h" +#include "GrClip.h" +#include "GrContext.h" +#include "GrTextUtils.h" +#include "SkColorFilter.h" +#include "SkDrawFilter.h" +#include "SkGlyphCache.h" +#include "SkMaskFilterBase.h" +#include "SkPaintPriv.h" +#include "SkTextBlobRunIterator.h" +#include "SkTextToPathIter.h" +#include "ops/GrAtlasTextOp.h" + +sk_sp<GrTextBlob> GrTextBlob::Make(int glyphCount, int runCount) { + // We allocate size for the GrTextBlob itself, plus size for the vertices array, + // and size for the glyphIds array. + size_t verticesCount = glyphCount * kVerticesPerGlyph * kMaxVASize; + size_t size = sizeof(GrTextBlob) + + verticesCount + + glyphCount * sizeof(GrGlyph**) + + sizeof(GrTextBlob::Run) * runCount; + + void* allocation = ::operator new (size); + + if (CACHE_SANITY_CHECK) { + sk_bzero(allocation, size); + } + + sk_sp<GrTextBlob> cacheBlob(new (allocation) GrTextBlob); + cacheBlob->fSize = size; + + // setup offsets for vertices / glyphs + cacheBlob->fVertices = sizeof(GrTextBlob) + reinterpret_cast<char*>(cacheBlob.get()); + cacheBlob->fGlyphs = reinterpret_cast<GrGlyph**>(cacheBlob->fVertices + verticesCount); + cacheBlob->fRuns = reinterpret_cast<GrTextBlob::Run*>(cacheBlob->fGlyphs + glyphCount); + + // Initialize runs + for (int i = 0; i < runCount; i++) { + new (&cacheBlob->fRuns[i]) GrTextBlob::Run; + } + cacheBlob->fRunCount = runCount; + return cacheBlob; +} + +SkExclusiveStrikePtr GrTextBlob::setupCache(int runIndex, + const SkSurfaceProps& props, + SkScalerContextFlags scalerContextFlags, + const SkPaint& skPaint, + const SkMatrix* viewMatrix) { + GrTextBlob::Run* run = &fRuns[runIndex]; + + // if we have an override descriptor for the run, then we should use that + SkAutoDescriptor* desc = run->fOverrideDescriptor.get() ? run->fOverrideDescriptor.get() : + &run->fDescriptor; + SkScalerContextEffects effects; + SkScalerContext::CreateDescriptorAndEffectsUsingPaint( + skPaint, &props, scalerContextFlags, viewMatrix, desc, &effects); + run->fTypeface = SkPaintPriv::RefTypefaceOrDefault(skPaint); + run->fPathEffect = sk_ref_sp(effects.fPathEffect); + run->fMaskFilter = sk_ref_sp(effects.fMaskFilter); + return SkStrikeCache::FindOrCreateStrikeExclusive(*desc->getDesc(), effects, *run->fTypeface); +} + +void GrTextBlob::appendGlyph(int runIndex, + const SkRect& positions, + GrColor color, + sk_sp<GrTextStrike> strike, + GrGlyph* glyph, + SkGlyphCache* cache, const SkGlyph& skGlyph, + SkScalar x, SkScalar y, SkScalar scale, bool preTransformed) { + if (positions.isEmpty()) { + return; + } + + // If the glyph is too large we fall back to paths + if (glyph->fTooLargeForAtlas) { + if (nullptr == glyph->fPath) { + const SkPath* glyphPath = cache->findPath(skGlyph); + if (!glyphPath) { + return; + } + + glyph->fPath = new SkPath(*glyphPath); + } + this->appendPathGlyph(runIndex, *glyph->fPath, x, y, scale, preTransformed); + return; + } + + Run& run = fRuns[runIndex]; + GrMaskFormat format = glyph->fMaskFormat; + + Run::SubRunInfo* subRun = &run.fSubRunInfo.back(); + if (run.fInitialized && subRun->maskFormat() != format) { + subRun = &run.push_back(); + subRun->setStrike(std::move(strike)); + } else if (!run.fInitialized) { + subRun->setStrike(std::move(strike)); + } + + run.fInitialized = true; + + bool hasW = subRun->hasWCoord(); + // glyphs drawn in perspective must always have a w coord. + SkASSERT(hasW || !fInitialViewMatrix.hasPerspective()); + + size_t vertexStride = GetVertexStride(format, hasW); + + subRun->setMaskFormat(format); + + subRun->joinGlyphBounds(positions); + subRun->setColor(color); + + intptr_t vertex = reinterpret_cast<intptr_t>(this->fVertices + subRun->vertexEndIndex()); + + // We always write the third position component used by SDFs. If it is unused it gets + // overwritten. Similarly, we always write the color and the blob will later overwrite it + // with texture coords if it is unused. + size_t colorOffset = hasW ? sizeof(SkPoint3) : sizeof(SkPoint); + // V0 + *reinterpret_cast<SkPoint3*>(vertex) = {positions.fLeft, positions.fTop, 1.f}; + *reinterpret_cast<GrColor*>(vertex + colorOffset) = color; + vertex += vertexStride; + + // V1 + *reinterpret_cast<SkPoint3*>(vertex) = {positions.fLeft, positions.fBottom, 1.f}; + *reinterpret_cast<GrColor*>(vertex + colorOffset) = color; + vertex += vertexStride; + + // V2 + *reinterpret_cast<SkPoint3*>(vertex) = {positions.fRight, positions.fTop, 1.f}; + *reinterpret_cast<GrColor*>(vertex + colorOffset) = color; + vertex += vertexStride; + + // V3 + *reinterpret_cast<SkPoint3*>(vertex) = {positions.fRight, positions.fBottom, 1.f}; + *reinterpret_cast<GrColor*>(vertex + colorOffset) = color; + + subRun->appendVertices(vertexStride); + fGlyphs[subRun->glyphEndIndex()] = glyph; + subRun->glyphAppended(); + subRun->setNeedsTransform(!preTransformed); +} + +void GrTextBlob::appendPathGlyph(int runIndex, const SkPath& path, SkScalar x, SkScalar y, + SkScalar scale, bool preTransformed) { + Run& run = fRuns[runIndex]; + run.fPathGlyphs.push_back(GrTextBlob::Run::PathGlyph(path, x, y, scale, preTransformed)); +} + +bool GrTextBlob::mustRegenerate(const GrTextUtils::Paint& paint, + const SkMaskFilterBase::BlurRec& blurRec, + const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { + // If we have LCD text then our canonical color will be set to transparent, in this case we have + // to regenerate the blob on any color change + // We use the grPaint to get any color filter effects + if (fKey.fCanonicalColor == SK_ColorTRANSPARENT && + fLuminanceColor != paint.luminanceColor()) { + return true; + } + + if (fInitialViewMatrix.hasPerspective() != viewMatrix.hasPerspective()) { + return true; + } + + /** This could be relaxed for blobs with only distance field glyphs. */ + if (fInitialViewMatrix.hasPerspective() && !fInitialViewMatrix.cheapEqualTo(viewMatrix)) { + return true; + } + + // We only cache one masked version + if (fKey.fHasBlur && + (fBlurRec.fSigma != blurRec.fSigma || fBlurRec.fStyle != blurRec.fStyle)) { + return true; + } + + // Similarly, we only cache one version for each style + if (fKey.fStyle != SkPaint::kFill_Style && + (fStrokeInfo.fFrameWidth != paint.skPaint().getStrokeWidth() || + fStrokeInfo.fMiterLimit != paint.skPaint().getStrokeMiter() || + fStrokeInfo.fJoin != paint.skPaint().getStrokeJoin())) { + return true; + } + + // Mixed blobs must be regenerated. We could probably figure out a way to do integer scrolls + // for mixed blobs if this becomes an issue. + if (this->hasBitmap() && this->hasDistanceField()) { + // Identical viewmatrices and we can reuse in all cases + if (fInitialViewMatrix.cheapEqualTo(viewMatrix) && x == fInitialX && y == fInitialY) { + return false; + } + return true; + } + + if (this->hasBitmap()) { + if (fInitialViewMatrix.getScaleX() != viewMatrix.getScaleX() || + fInitialViewMatrix.getScaleY() != viewMatrix.getScaleY() || + fInitialViewMatrix.getSkewX() != viewMatrix.getSkewX() || + fInitialViewMatrix.getSkewY() != viewMatrix.getSkewY()) { + return true; + } + + // We can update the positions in the cachedtextblobs without regenerating the whole blob, + // but only for integer translations. + // This cool bit of math will determine the necessary translation to apply to the already + // generated vertex coordinates to move them to the correct position + SkScalar transX = viewMatrix.getTranslateX() + + viewMatrix.getScaleX() * (x - fInitialX) + + viewMatrix.getSkewX() * (y - fInitialY) - + fInitialViewMatrix.getTranslateX(); + SkScalar transY = viewMatrix.getTranslateY() + + viewMatrix.getSkewY() * (x - fInitialX) + + viewMatrix.getScaleY() * (y - fInitialY) - + fInitialViewMatrix.getTranslateY(); + if (!SkScalarIsInt(transX) || !SkScalarIsInt(transY)) { + return true; + } + } else if (this->hasDistanceField()) { + // A scale outside of [blob.fMaxMinScale, blob.fMinMaxScale] would result in a different + // distance field being generated, so we have to regenerate in those cases + SkScalar newMaxScale = viewMatrix.getMaxScale(); + SkScalar oldMaxScale = fInitialViewMatrix.getMaxScale(); + SkScalar scaleAdjust = newMaxScale / oldMaxScale; + if (scaleAdjust < fMaxMinScale || scaleAdjust > fMinMaxScale) { + return true; + } + } + + // It is possible that a blob has neither distanceField nor bitmaptext. This is in the case + // when all of the runs inside the blob are drawn as paths. In this case, we always regenerate + // the blob anyways at flush time, so no need to regenerate explicitly + return false; +} + +inline std::unique_ptr<GrAtlasTextOp> GrTextBlob::makeOp( + const Run::SubRunInfo& info, int glyphCount, uint16_t run, uint16_t subRun, + const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const SkIRect& clipRect, + const GrTextUtils::Paint& paint, const SkSurfaceProps& props, + const GrDistanceFieldAdjustTable* distanceAdjustTable, GrTextUtils::Target* target) { + GrMaskFormat format = info.maskFormat(); + + GrPaint grPaint; + target->makeGrPaint(info.maskFormat(), paint, viewMatrix, &grPaint); + std::unique_ptr<GrAtlasTextOp> op; + if (info.drawAsDistanceFields()) { + op = GrAtlasTextOp::MakeDistanceField( + std::move(grPaint), glyphCount, distanceAdjustTable, + target->colorSpaceInfo().isGammaCorrect(), paint.luminanceColor(), + props, info.isAntiAliased(), info.hasUseLCDText()); + } else { + op = GrAtlasTextOp::MakeBitmap(std::move(grPaint), format, glyphCount, + info.needsTransform()); + } + GrAtlasTextOp::Geometry& geometry = op->geometry(); + geometry.fViewMatrix = viewMatrix; + geometry.fClipRect = clipRect; + geometry.fBlob = SkRef(this); + geometry.fRun = run; + geometry.fSubRun = subRun; + geometry.fColor = + info.maskFormat() == kARGB_GrMaskFormat ? GrColor_WHITE : paint.filteredPremulColor(); + geometry.fX = x; + geometry.fY = y; + op->init(); + return op; +} + +static void calculate_translation(bool applyVM, + const SkMatrix& newViewMatrix, SkScalar newX, SkScalar newY, + const SkMatrix& currentViewMatrix, SkScalar currentX, + SkScalar currentY, SkScalar* transX, SkScalar* transY) { + if (applyVM) { + *transX = newViewMatrix.getTranslateX() + + newViewMatrix.getScaleX() * (newX - currentX) + + newViewMatrix.getSkewX() * (newY - currentY) - + currentViewMatrix.getTranslateX(); + + *transY = newViewMatrix.getTranslateY() + + newViewMatrix.getSkewY() * (newX - currentX) + + newViewMatrix.getScaleY() * (newY - currentY) - + currentViewMatrix.getTranslateY(); + } else { + *transX = newX - currentX; + *transY = newY - currentY; + } +} + +void GrTextBlob::flush(GrTextUtils::Target* target, const SkSurfaceProps& props, + const GrDistanceFieldAdjustTable* distanceAdjustTable, + const GrTextUtils::Paint& paint, const GrClip& clip, + const SkMatrix& viewMatrix, const SkIRect& clipBounds, + 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; + GrTextUtils::RunPaint runPaint(&paint, nullptr); + for (int runIndex = 0; runIndex <= lastRun; runIndex++) { + Run& run = fRuns[runIndex]; + + // first flush any path glyphs + if (run.fPathGlyphs.count()) { + SkScalar transX, transY; + uint16_t paintFlags = run.fPaintFlags; + if (!runPaint.modifyForRun( + [paintFlags](SkPaint* p) { + p->setFlags((p->getFlags() & ~Run::kPaintFlagsMask) | paintFlags); + })) { + continue; + } + for (int i = 0; i < run.fPathGlyphs.count(); i++) { + GrTextBlob::Run::PathGlyph& pathGlyph = run.fPathGlyphs[i]; + calculate_translation(pathGlyph.fPreTransformed, viewMatrix, x, y, + fInitialViewMatrix, fInitialX, fInitialY, &transX, &transY); + const SkMatrix& ctm = pathGlyph.fPreTransformed ? SkMatrix::I() : viewMatrix; + SkMatrix pathMatrix; + pathMatrix.setScale(pathGlyph.fScale, pathGlyph.fScale); + pathMatrix.postTranslate(pathGlyph.fX + transX, pathGlyph.fY + transY); + target->drawPath(clip, pathGlyph.fPath, runPaint, ctm, &pathMatrix, clipBounds); + } + } + + // 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); + 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, std::move(paint), props, distanceAdjustTable, + target); + if (op) { + if (skipClip) { + target->addDrawOp(GrNoClip(), std::move(op)); + } + else { + target->addDrawOp(clip, std::move(op)); + } + } + } + } + + } +} + +std::unique_ptr<GrDrawOp> GrTextBlob::test_makeOp( + int glyphCount, uint16_t run, uint16_t subRun, const SkMatrix& viewMatrix, + SkScalar x, SkScalar y, const GrTextUtils::Paint& paint, const SkSurfaceProps& props, + const GrDistanceFieldAdjustTable* distanceAdjustTable, GrTextUtils::Target* target) { + const GrTextBlob::Run::SubRunInfo& info = fRuns[run].fSubRunInfo[subRun]; + SkIRect emptyRect = SkIRect::MakeEmpty(); + return this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y, emptyRect, paint, props, + distanceAdjustTable, target); +} + +void GrTextBlob::AssertEqual(const GrTextBlob& l, const GrTextBlob& r) { + SkASSERT_RELEASE(l.fSize == r.fSize); + + SkASSERT_RELEASE(l.fBlurRec.fSigma == r.fBlurRec.fSigma); + SkASSERT_RELEASE(l.fBlurRec.fStyle == r.fBlurRec.fStyle); + + SkASSERT_RELEASE(l.fStrokeInfo.fFrameWidth == r.fStrokeInfo.fFrameWidth); + SkASSERT_RELEASE(l.fStrokeInfo.fMiterLimit == r.fStrokeInfo.fMiterLimit); + SkASSERT_RELEASE(l.fStrokeInfo.fJoin == r.fStrokeInfo.fJoin); + + SkASSERT_RELEASE(l.fKey == r.fKey); + //SkASSERT_RELEASE(l.fPaintColor == r.fPaintColor); // Colors might not actually be identical + SkASSERT_RELEASE(l.fMaxMinScale == r.fMaxMinScale); + SkASSERT_RELEASE(l.fMinMaxScale == r.fMinMaxScale); + SkASSERT_RELEASE(l.fTextType == r.fTextType); + + SkASSERT_RELEASE(l.fRunCount == r.fRunCount); + for (int i = 0; i < l.fRunCount; i++) { + const Run& lRun = l.fRuns[i]; + const Run& rRun = r.fRuns[i]; + + if (lRun.fTypeface.get()) { + SkASSERT_RELEASE(rRun.fTypeface.get()); + SkASSERT_RELEASE(SkTypeface::Equal(lRun.fTypeface.get(), rRun.fTypeface.get())); + } else { + SkASSERT_RELEASE(!rRun.fTypeface.get()); + } + + + SkASSERT_RELEASE(lRun.fDescriptor.getDesc()); + SkASSERT_RELEASE(rRun.fDescriptor.getDesc()); + SkASSERT_RELEASE(*lRun.fDescriptor.getDesc() == *rRun.fDescriptor.getDesc()); + + if (lRun.fOverrideDescriptor.get()) { + SkASSERT_RELEASE(lRun.fOverrideDescriptor->getDesc()); + SkASSERT_RELEASE(rRun.fOverrideDescriptor.get() && rRun.fOverrideDescriptor->getDesc()); + SkASSERT_RELEASE(*lRun.fOverrideDescriptor->getDesc() == + *rRun.fOverrideDescriptor->getDesc()); + } else { + SkASSERT_RELEASE(!rRun.fOverrideDescriptor.get()); + } + + // color can be changed + //SkASSERT(lRun.fColor == rRun.fColor); + SkASSERT_RELEASE(lRun.fInitialized == rRun.fInitialized); + + SkASSERT_RELEASE(lRun.fSubRunInfo.count() == rRun.fSubRunInfo.count()); + for(int j = 0; j < lRun.fSubRunInfo.count(); j++) { + const Run::SubRunInfo& lSubRun = lRun.fSubRunInfo[j]; + const Run::SubRunInfo& rSubRun = rRun.fSubRunInfo[j]; + + // TODO we can do this check, but we have to apply the VM to the old vertex bounds + //SkASSERT_RELEASE(lSubRun.vertexBounds() == rSubRun.vertexBounds()); + + if (lSubRun.strike()) { + SkASSERT_RELEASE(rSubRun.strike()); + SkASSERT_RELEASE(GrTextStrike::GetKey(*lSubRun.strike()) == + GrTextStrike::GetKey(*rSubRun.strike())); + + } else { + SkASSERT_RELEASE(!rSubRun.strike()); + } + + SkASSERT_RELEASE(lSubRun.vertexStartIndex() == rSubRun.vertexStartIndex()); + SkASSERT_RELEASE(lSubRun.vertexEndIndex() == rSubRun.vertexEndIndex()); + SkASSERT_RELEASE(lSubRun.glyphStartIndex() == rSubRun.glyphStartIndex()); + SkASSERT_RELEASE(lSubRun.glyphEndIndex() == rSubRun.glyphEndIndex()); + SkASSERT_RELEASE(lSubRun.maskFormat() == rSubRun.maskFormat()); + SkASSERT_RELEASE(lSubRun.drawAsDistanceFields() == rSubRun.drawAsDistanceFields()); + SkASSERT_RELEASE(lSubRun.hasUseLCDText() == rSubRun.hasUseLCDText()); + } + + SkASSERT_RELEASE(lRun.fPathGlyphs.count() == rRun.fPathGlyphs.count()); + for (int i = 0; i < lRun.fPathGlyphs.count(); i++) { + const Run::PathGlyph& lPathGlyph = lRun.fPathGlyphs[i]; + const Run::PathGlyph& rPathGlyph = rRun.fPathGlyphs[i]; + + SkASSERT_RELEASE(lPathGlyph.fPath == rPathGlyph.fPath); + // We can't assert that these have the same translations + } + } +} + +void GrTextBlob::Run::SubRunInfo::computeTranslation(const SkMatrix& viewMatrix, + SkScalar x, SkScalar y, SkScalar* transX, + SkScalar* transY) { + calculate_translation(!this->drawAsDistanceFields(), viewMatrix, x, y, + fCurrentViewMatrix, fX, fY, transX, transY); + fCurrentViewMatrix = viewMatrix; + fX = x; + fY = y; +} |