| /* | |
| * 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 "GrShape.h" | |
| #include "GrStyle.h" | |
| #include "GrTextTarget.h" | |
| #include "SkColorFilter.h" | |
| #include "SkMaskFilterBase.h" | |
| #include "SkPaintPriv.h" | |
| #include "ops/GrAtlasTextOp.h" | |
| #include <new> | |
| template <size_t N> static size_t sk_align(size_t s) { | |
| return ((s + (N-1)) / N) * N; | |
| } | |
| sk_sp<GrTextBlob> GrTextBlob::Make(int glyphCount, | |
| int runCount, | |
| GrColor color, | |
| GrStrikeCache* strikeCache) { | |
| // 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 blobStart = 0; | |
| size_t vertex = sk_align<alignof(char)> (blobStart + sizeof(GrTextBlob) * 1); | |
| size_t glyphs = sk_align<alignof(GrGlyph*)> (vertex + sizeof(char) * verticesCount); | |
| size_t runs = sk_align<alignof(GrTextBlob::Run)>(glyphs + sizeof(GrGlyph*) * glyphCount); | |
| size_t size = (runs + sizeof(GrTextBlob::Run) * runCount); | |
| void* allocation = ::operator new (size); | |
| if (CACHE_SANITY_CHECK) { | |
| sk_bzero(allocation, size); | |
| } | |
| sk_sp<GrTextBlob> blob{new (allocation) GrTextBlob{strikeCache}}; | |
| blob->fSize = size; | |
| // setup offsets for vertices / glyphs | |
| blob->fVertices = SkTAddOffset<char>(blob.get(), vertex); | |
| blob->fGlyphs = SkTAddOffset<GrGlyph*>(blob.get(), glyphs); | |
| blob->fRuns = SkTAddOffset<GrTextBlob::Run>(blob.get(), runs); | |
| // Initialize runs | |
| for (int i = 0; i < runCount; i++) { | |
| new (&blob->fRuns[i]) GrTextBlob::Run{blob.get(), color}; | |
| } | |
| blob->fRunCountLimit = runCount; | |
| return blob; | |
| } | |
| void GrTextBlob::Run::setupFont(const SkStrikeSpec& strikeSpec) { | |
| fTypeface = sk_ref_sp(&strikeSpec.typeface()); | |
| fPathEffect = sk_ref_sp(strikeSpec.effects().fPathEffect); | |
| fMaskFilter = sk_ref_sp(strikeSpec.effects().fMaskFilter); | |
| // if we have an override descriptor for the run, then we should use that | |
| SkAutoDescriptor* desc = | |
| fARGBFallbackDescriptor.get() ? fARGBFallbackDescriptor.get() : &fDescriptor; | |
| // Set up the descriptor for possible cache lookups during regen. | |
| desc->reset(strikeSpec.desc()); | |
| } | |
| void GrTextBlob::Run::appendPathGlyph(const SkPath& path, SkPoint position, | |
| SkScalar scale, bool preTransformed) { | |
| fPathGlyphs.push_back(PathGlyph(path, position.x(), position.y(), scale, preTransformed)); | |
| } | |
| bool GrTextBlob::mustRegenerate(const SkPaint& paint, bool anyRunHasSubpixelPosition, | |
| 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 != SkPaintPriv::ComputeLuminanceColor(paint)) { | |
| 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.getStrokeWidth() || | |
| fStrokeInfo.fMiterLimit != paint.getStrokeMiter() || | |
| fStrokeInfo.fJoin != paint.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; | |
| } | |
| // If the text blob only has full pixel glyphs, then fractional part of the position does | |
| // not affect the SkGlyphs used. | |
| if (anyRunHasSubpixelPosition) { | |
| // We can update the positions in the text blob 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 SubRun& info, int glyphCount, uint16_t run, uint16_t subRun, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const SkIRect& clipRect, | |
| const SkPaint& paint, const SkPMColor4f& filteredColor, const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, GrTextTarget* target) { | |
| GrMaskFormat format = info.maskFormat(); | |
| GrPaint grPaint; | |
| target->makeGrPaint(info.maskFormat(), paint, viewMatrix, &grPaint); | |
| std::unique_ptr<GrAtlasTextOp> op; | |
| if (info.drawAsDistanceFields()) { | |
| // TODO: Can we be even smarter based on the dest transfer function? | |
| op = GrAtlasTextOp::MakeDistanceField( | |
| target->getContext(), std::move(grPaint), glyphCount, distanceAdjustTable, | |
| target->colorSpaceInfo().isLinearlyBlended(), | |
| SkPaintPriv::ComputeLuminanceColor(paint), | |
| props, info.isAntiAliased(), info.hasUseLCDText()); | |
| } else { | |
| op = GrAtlasTextOp::MakeBitmap(target->getContext(), 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 ? SK_PMColor4fWHITE : filteredColor; | |
| 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(GrTextTarget* target, const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| const SkPaint& paint, const SkPMColor4f& 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(fRunCountLimit, (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.setAntiAlias(run.fAntiAlias); | |
| 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 SubRun& 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)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| std::unique_ptr<GrDrawOp> GrTextBlob::test_makeOp( | |
| int glyphCount, uint16_t run, uint16_t subRun, const SkMatrix& viewMatrix, | |
| SkScalar x, SkScalar y, const SkPaint& paint, const SkPMColor4f& filteredColor, | |
| const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| GrTextTarget* target) { | |
| const GrTextBlob::SubRun& info = fRuns[run].fSubRunInfo[subRun]; | |
| SkIRect emptyRect = SkIRect::MakeEmpty(); | |
| return this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y, emptyRect, | |
| paint, filteredColor, 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.fRunCountLimit == r.fRunCountLimit); | |
| for (int i = 0; i < l.fRunCountLimit; 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.fARGBFallbackDescriptor.get()) { | |
| SkASSERT_RELEASE(lRun.fARGBFallbackDescriptor->getDesc()); | |
| SkASSERT_RELEASE(rRun.fARGBFallbackDescriptor.get() && rRun.fARGBFallbackDescriptor->getDesc()); | |
| SkASSERT_RELEASE(*lRun.fARGBFallbackDescriptor->getDesc() == | |
| *rRun.fARGBFallbackDescriptor->getDesc()); | |
| } else { | |
| SkASSERT_RELEASE(!rRun.fARGBFallbackDescriptor.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 SubRun& lSubRun = lRun.fSubRunInfo[j]; | |
| const SubRun& 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::SubRun::computeTranslation(const SkMatrix& viewMatrix, | |
| SkScalar x, SkScalar y, SkScalar* transX, | |
| SkScalar* transY) { | |
| // Don't use the matrix to translate on distance field for fallback subruns. | |
| calculate_translation(!this->drawAsDistanceFields() && !this->isFallback(), viewMatrix, | |
| x, y, fCurrentViewMatrix, fX, fY, transX, transY); | |
| fCurrentViewMatrix = viewMatrix; | |
| fX = x; | |
| fY = y; | |
| } |