sktext::gpu::TextBlob::Key Struct Reference

#include <TextBlob.h>

Public Member Functions
bool	operator== (const Key &other) const

Static Public Member Functions
static std::tuple< bool, Key >	Make (const GlyphRunList &glyphRunList, const SkPaint &paint, const SkMatrix &drawMatrix, const SkStrikeDeviceInfo &strikeDevice)

Public Attributes
uint32_t	fUniqueID
SkColor	fCanonicalColor
SkScalar	fFrameWidth
SkScalar	fMiterLimit
SkPixelGeometry	fPixelGeometry
SkMaskFilterBase::BlurRec	fBlurRec
uint32_t	fScalerContextFlags
SkMatrix	fPositionMatrix
bool	fHasSomeDirectSubRuns
bool	fHasBlur
SkPaint::Style	fStyle
SkPaint::Join	fJoin

Detailed Description

Definition at line 58 of file TextBlob.h.

Member Function Documentation

Make()

auto sktext::gpu::TextBlob::Key::Make ( const GlyphRunList &  glyphRunList, const SkPaint &  paint, const SkMatrix &  drawMatrix, const SkStrikeDeviceInfo &  strikeDevice  )

static

Definition at line 84 of file TextBlob.cpp.

                                                                                        {
    SkASSERT(strikeDevice.fSDFTControl != nullptr);
    SkMaskFilterBase::BlurRec blurRec;
    // It might be worth caching these things, but its not clear at this time
    // TODO for animated mask filters, this will fill up our cache.  We need a safeguard here
    const SkMaskFilter* maskFilter = paint.getMaskFilter();
    bool canCache = glyphRunList.canCache() &&
                    !(paint.getPathEffect() ||
                        (maskFilter && !as_MFB(maskFilter)->asABlur(&blurRec)));
 
    TextBlob::Key key;
    if (canCache) {
        bool hasLCD = glyphRunList.anyRunsLCD();
 
        // We canonicalize all non-lcd draws to use kUnknown_SkPixelGeometry
        SkPixelGeometry pixelGeometry = hasLCD ? strikeDevice.fSurfaceProps.pixelGeometry()
                                               : kUnknown_SkPixelGeometry;
 
        SkColor canonicalColor = compute_canonical_color(paint, hasLCD);
 
        key.fPixelGeometry = pixelGeometry;
        key.fUniqueID = glyphRunList.uniqueID();
        key.fStyle = paint.getStyle();
        if (key.fStyle != SkPaint::kFill_Style) {
            key.fFrameWidth = paint.getStrokeWidth();
            key.fMiterLimit = paint.getStrokeMiter();
            key.fJoin = paint.getStrokeJoin();
        }
        key.fHasBlur = maskFilter != nullptr;
        if (key.fHasBlur) {
            key.fBlurRec = blurRec;
        }
        key.fCanonicalColor = canonicalColor;
        key.fScalerContextFlags = SkTo<uint32_t>(strikeDevice.fScalerContextFlags);
 
        // Do any runs use direct drawing types?.
        key.fHasSomeDirectSubRuns = false;
        SkPoint glyphRunListLocation = glyphRunList.sourceBoundsWithOrigin().center();
        for (auto& run : glyphRunList) {
            SkScalar approximateDeviceTextSize =
                    SkFontPriv::ApproximateTransformedTextSize(run.font(), drawMatrix,
                                                               glyphRunListLocation);
            key.fHasSomeDirectSubRuns |=
                    strikeDevice.fSDFTControl->isDirect(approximateDeviceTextSize, paint,
                                                        drawMatrix);
        }
 
        if (key.fHasSomeDirectSubRuns) {
            // Store the fractional offset of the position. We know that the matrix can't be
            // perspective at this point.
            SkPoint mappedOrigin = drawMatrix.mapOrigin();
            key.fPositionMatrix = drawMatrix;
            key.fPositionMatrix.setTranslateX(
                    mappedOrigin.x() - SkScalarFloorToScalar(mappedOrigin.x()));
            key.fPositionMatrix.setTranslateY(
                    mappedOrigin.y() - SkScalarFloorToScalar(mappedOrigin.y()));
        } else {
            // For path and SDFT, the matrix doesn't matter.
            key.fPositionMatrix = SkMatrix::I();
        }
    }
 
    return {canCache, key};
}

operator==()

bool sktext::gpu::TextBlob::Key::operator==

(

const Key &

other

)

const

Definition at line 152 of file TextBlob.cpp.

                                                          {
    if (fUniqueID != that.fUniqueID) { return false; }
    if (fCanonicalColor != that.fCanonicalColor) { return false; }
    if (fStyle != that.fStyle) { return false; }
    if (fStyle != SkPaint::kFill_Style) {
        if (fFrameWidth != that.fFrameWidth ||
            fMiterLimit != that.fMiterLimit ||
            fJoin != that.fJoin) {
            return false;
        }
    }
    if (fPixelGeometry != that.fPixelGeometry) { return false; }
    if (fHasBlur != that.fHasBlur) { return false; }
    if (fHasBlur) {
        if (fBlurRec.fStyle != that.fBlurRec.fStyle || fBlurRec.fSigma != that.fBlurRec.fSigma) {
            return false;
        }
    }
 
    if (fScalerContextFlags != that.fScalerContextFlags) { return false; }
 
    // DirectSubRuns do not support perspective when used with a TextBlob. SDFT, Transformed,
    // Path, and Drawable do support perspective.
    if (fPositionMatrix.hasPerspective() && fHasSomeDirectSubRuns) { return false; }
 
    if (fHasSomeDirectSubRuns != that.fHasSomeDirectSubRuns) { return false; }
 
    if (fHasSomeDirectSubRuns) {
        auto [compatible, _] = can_use_direct(fPositionMatrix, that.fPositionMatrix);
        return compatible;
    }
 
    return true;
}

Member Data Documentation

fBlurRec

SkMaskFilterBase::BlurRec sktext::gpu::TextBlob::Key::fBlurRec

Definition at line 72 of file TextBlob.h.

fCanonicalColor

SkColor sktext::gpu::TextBlob::Key::fCanonicalColor

Definition at line 68 of file TextBlob.h.

fFrameWidth

SkScalar sktext::gpu::TextBlob::Key::fFrameWidth

Definition at line 69 of file TextBlob.h.

fHasBlur

bool sktext::gpu::TextBlob::Key::fHasBlur

Definition at line 77 of file TextBlob.h.

fHasSomeDirectSubRuns

bool sktext::gpu::TextBlob::Key::fHasSomeDirectSubRuns

Definition at line 76 of file TextBlob.h.

fJoin

SkPaint::Join sktext::gpu::TextBlob::Key::fJoin

Definition at line 79 of file TextBlob.h.

fMiterLimit

SkScalar sktext::gpu::TextBlob::Key::fMiterLimit

Definition at line 70 of file TextBlob.h.

fPixelGeometry

SkPixelGeometry sktext::gpu::TextBlob::Key::fPixelGeometry

Definition at line 71 of file TextBlob.h.

fPositionMatrix

SkMatrix sktext::gpu::TextBlob::Key::fPositionMatrix

Definition at line 74 of file TextBlob.h.

fScalerContextFlags

uint32_t sktext::gpu::TextBlob::Key::fScalerContextFlags

Definition at line 73 of file TextBlob.h.

fStyle

SkPaint::Style sktext::gpu::TextBlob::Key::fStyle

Definition at line 78 of file TextBlob.h.

fUniqueID

uint32_t sktext::gpu::TextBlob::Key::fUniqueID

Definition at line 63 of file TextBlob.h.

---

The documentation for this struct was generated from the following files:

• third_party/skia/src/text/gpu/TextBlob.h
• third_party/skia/src/text/gpu/TextBlob.cpp