sktext::GlyphRunBuilder Class Reference

#include <GlyphRun.h>

Public Member Functions
GlyphRunList	makeGlyphRunList (const GlyphRun &run, const SkPaint &paint, SkPoint origin)
const GlyphRunList &	textToGlyphRunList (const SkFont &font, const SkPaint &paint, const void *bytes, size_t byteLength, SkPoint origin, SkTextEncoding encoding=SkTextEncoding::kUTF8)
const GlyphRunList &	blobToGlyphRunList (const SkTextBlob &blob, SkPoint origin)
std::tuple< SkSpan< const SkPoint >, SkSpan< const SkVector > >	convertRSXForm (SkSpan< const SkRSXform > xforms)
bool	empty () const

Detailed Description

Definition at line 137 of file GlyphRun.h.

Member Function Documentation

blobToGlyphRunList()

const GlyphRunList & sktext::GlyphRunBuilder::blobToGlyphRunList	(	const SkTextBlob &	blob,
		SkPoint	origin
	)

Definition at line 233 of file GlyphRun.cpp.

                                                {
    // Pre-size all the buffers, so they don't move during processing.
    this->initialize(blob);
 
    SkPoint* positionCursor = fPositions;
    SkVector* scaledRotationsCursor = fScaledRotations;
    for (SkTextBlobRunIterator it(&blob); !it.done(); it.next()) {
        size_t runSize = it.glyphCount();
        if (runSize == 0 || !SkFontPriv::IsFinite(it.font())) {
            // If no glyphs or the font is not finite, don't add the run.
            continue;
        }
 
        const SkFont& font = it.font();
        auto glyphIDs = SkSpan<const SkGlyphID>{it.glyphs(), runSize};
 
        SkSpan<const SkPoint> positions;
        SkSpan<const SkVector> scaledRotations;
        switch (it.positioning()) {
            case SkTextBlobRunIterator::kDefault_Positioning: {
                positions = draw_text_positions(font, glyphIDs, it.offset(), positionCursor);
                positionCursor += positions.size();
                break;
            }
            case SkTextBlobRunIterator::kHorizontal_Positioning: {
                positions = SkSpan(positionCursor, runSize);
                for (auto x : SkSpan<const SkScalar>{it.pos(), glyphIDs.size()}) {
                    *positionCursor++ = SkPoint::Make(x, it.offset().y());
                }
                break;
            }
            case SkTextBlobRunIterator::kFull_Positioning: {
                positions = SkSpan(it.points(), runSize);
                break;
            }
            case SkTextBlobRunIterator::kRSXform_Positioning: {
                positions = SkSpan(positionCursor, runSize);
                scaledRotations = SkSpan(scaledRotationsCursor, runSize);
                for (const SkRSXform& xform : SkSpan(it.xforms(), runSize)) {
                    *positionCursor++ = {xform.fTx, xform.fTy};
                    *scaledRotationsCursor++ = {xform.fSCos, xform.fSSin};
                }
                break;
            }
        }
 
        const uint32_t* clusters = it.clusters();
        this->makeGlyphRun(
                font,
                glyphIDs,
                positions,
                SkSpan<const char>(it.text(), it.textSize()),
                SkSpan<const uint32_t>(clusters, clusters ? runSize : 0),
                scaledRotations);
    }
 
    return this->setGlyphRunList(&blob, blob.bounds(), origin);
}

convertRSXForm()

std::tuple< SkSpan< const SkPoint >, SkSpan< const SkVector > > sktext::GlyphRunBuilder::convertRSXForm

(

SkSpan< const SkRSXform >

xforms

)

Definition at line 294 of file GlyphRun.cpp.

                                                              {
    const int count = SkCount(xforms);
    this->prepareBuffers(count, count);
    auto positions = SkSpan(fPositions.get(), count);
    auto scaledRotations = SkSpan(fScaledRotations.get(), count);
    for (auto [pos, sr, xform] : SkMakeZip(positions, scaledRotations, xforms)) {
        auto [scos, ssin, tx, ty] = xform;
        pos = {tx, ty};
        sr = {scos, ssin};
    }
    return {positions, scaledRotations};
}

empty()

bool sktext::GlyphRunBuilder::empty ( ) const

inline

Definition at line 150 of file GlyphRun.h.

{ return fGlyphRunListStorage.empty(); }

makeGlyphRunList()

GlyphRunList sktext::GlyphRunBuilder::makeGlyphRunList	(	const GlyphRun &	run,
		const SkPaint &	paint,
		SkPoint	origin
	)

Definition at line 189 of file GlyphRun.cpp.

                                                                   {
    const SkRect bounds =
            glyphrun_source_bounds(run.font(), paint, run.source(), run.scaledRotations());
    return GlyphRunList{run, bounds, origin, this};
}

textToGlyphRunList()

const GlyphRunList & sktext::GlyphRunBuilder::textToGlyphRunList	(	const SkFont &	font,
		const SkPaint &	paint,
		const void *	bytes,
		size_t	byteLength,
		SkPoint	origin,
		SkTextEncoding	encoding = SkTextEncoding::kUTF8
	)

Definition at line 211 of file GlyphRun.cpp.

                                 {
    auto glyphIDs = textToGlyphIDs(font, bytes, byteLength, encoding);
    SkRect bounds = SkRect::MakeEmpty();
    this->prepareBuffers(glyphIDs.size(), 0);
    if (!glyphIDs.empty()) {
        SkSpan<const SkPoint> positions = draw_text_positions(font, glyphIDs, {0, 0}, fPositions);
        this->makeGlyphRun(font,
                           glyphIDs,
                           positions,
                           SkSpan<const char>{},
                           SkSpan<const uint32_t>{},
                           SkSpan<const SkVector>{});
        auto run = fGlyphRunListStorage.front();
        bounds = glyphrun_source_bounds(run.font(), paint, run.source(), run.scaledRotations());
    }
 
    return this->setGlyphRunList(nullptr, bounds, origin);
}

---

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

• third_party/skia/src/text/GlyphRun.h
• third_party/skia/src/text/GlyphRun.cpp