sktext::gpu::GlyphVector Class Reference

#include <GlyphVector.h>

Classes
union	Variant

Public Member Functions
	GlyphVector (SkStrikePromise &&strikePromise, SkSpan< Variant > glyphs)
SkSpan< const Glyph * >	glyphs () const
void	flatten (SkWriteBuffer &buffer) const
int	unflattenSize () const
void	packedGlyphIDToGlyph (StrikeCache *cache)

Static Public Member Functions
static GlyphVector	Make (SkStrikePromise &&promise, SkSpan< const SkPackedGlyphID > glyphs, SubRunAllocator *alloc)
static std::optional< GlyphVector >	MakeFromBuffer (SkReadBuffer &buffer, const SkStrikeClient *strikeClient, SubRunAllocator *alloc)
static size_t	GlyphVectorSize (size_t count)

Friends
class	GlyphVectorTestingPeer
class	::skgpu::graphite::Device
class	::skgpu::ganesh::AtlasTextOp

Detailed Description

Definition at line 42 of file GlyphVector.h.

Constructor & Destructor Documentation

GlyphVector()

sktext::gpu::GlyphVector::GlyphVector	(	SkStrikePromise &&	strikePromise,
		SkSpan< Variant >	glyphs
	)

Definition at line 32 of file GlyphVector.cpp.

        : fStrikePromise{std::move(strikePromise)}
        , fGlyphs{glyphs} {
    SkASSERT(fGlyphs.size() > 0);
}

Member Function Documentation

flatten()

void sktext::gpu::GlyphVector::flatten

(

SkWriteBuffer &

buffer

)

const

Definition at line 84 of file GlyphVector.cpp.

                                                     {
    // There should never be a glyph vector with zero glyphs.
    SkASSERT(fGlyphs.size() != 0);
    fStrikePromise.flatten(buffer);
 
    // Write out the span of packedGlyphIDs.
    buffer.write32(SkTo<int32_t>(fGlyphs.size()));
    for (Variant variant : fGlyphs) {
        buffer.writeUInt(variant.packedGlyphID.value());
    }
}

glyphs()

SkSpan< const Glyph * > sktext::gpu::GlyphVector::glyphs

(

)

const

Definition at line 96 of file GlyphVector.cpp.

                                               {
    return SkSpan(reinterpret_cast<const Glyph**>(fGlyphs.data()), fGlyphs.size());
}

GlyphVectorSize()

static size_t sktext::gpu::GlyphVector::GlyphVectorSize ( size_t  count )

inlinestatic

Definition at line 72 of file GlyphVector.h.

                                                {
        return sizeof(Variant) * count;
    }

Make()

GlyphVector sktext::gpu::GlyphVector::Make ( SkStrikePromise &&  promise, SkSpan< const SkPackedGlyphID >  glyphs, SubRunAllocator *  alloc  )

static

Definition at line 38 of file GlyphVector.cpp.

                                                      {
    SkASSERT(packedIDs.size() > 0);
    auto packedIDToVariant = [] (SkPackedGlyphID packedID) {
        return Variant{packedID};
    };
 
    return GlyphVector{std::move(promise),
                       alloc->makePODArray<Variant>(packedIDs, packedIDToVariant)};
}

MakeFromBuffer()

std::optional< GlyphVector > sktext::gpu::GlyphVector::MakeFromBuffer ( SkReadBuffer &  buffer, const SkStrikeClient *  strikeClient, SubRunAllocator *  alloc  )

static

Definition at line 50 of file GlyphVector.cpp.

                                                                               {
    std::optional<SkStrikePromise> promise =
            SkStrikePromise::MakeFromBuffer(buffer, client, SkStrikeCache::GlobalStrikeCache());
    if (!buffer.validate(promise.has_value())) {
        return std::nullopt;
    }
 
    int32_t glyphCount = buffer.read32();
    // Since the glyph count can never be zero. There was a buffer reading problem.
    if (!buffer.validate(glyphCount > 0)) {
        return std::nullopt;
    }
 
    // Make sure we can multiply without overflow in the check below.
    static constexpr int kMaxCount = (int)(INT_MAX / sizeof(uint32_t));
    if (!buffer.validate(glyphCount <= kMaxCount)) {
        return std::nullopt;
    }
 
    // Check for enough bytes to populate the packedGlyphID array. If not enough something has
    // gone wrong.
    if (!buffer.validate(glyphCount * sizeof(uint32_t) <= buffer.available())) {
        return std::nullopt;
    }
 
    Variant* variants = alloc->makePODArray<Variant>(glyphCount);
    for (int i = 0; i < glyphCount; i++) {
        variants[i].packedGlyphID = SkPackedGlyphID(buffer.readUInt());
    }
    return GlyphVector{std::move(promise.value()), SkSpan(variants, glyphCount)};
}

packedGlyphIDToGlyph()

void sktext::gpu::GlyphVector::packedGlyphIDToGlyph

(

StrikeCache *

cache

)

Definition at line 102 of file GlyphVector.cpp.

                                                         {
    if (fTextStrike == nullptr) {
        SkStrike* strike = fStrikePromise.strike();
        fTextStrike = cache->findOrCreateStrike(strike->strikeSpec());
 
        // Get all the atlas locations for each glyph.
        for (Variant& variant : fGlyphs) {
            variant.glyph = fTextStrike->getGlyph(variant.packedGlyphID);
        }
 
        // This must be pinned for the Atlas filling to work.
        strike->verifyPinnedStrike();
 
        // Drop the ref to the strike so that it can be purged if needed.
        fStrikePromise.resetStrike();
    }
}

unflattenSize()

int sktext::gpu::GlyphVector::unflattenSize ( ) const

inline

Definition at line 68 of file GlyphVector.h.

{ return GlyphVectorSize(fGlyphs.size()); }

Friends And Related Function Documentation

::skgpu::ganesh::AtlasTextOp

friend class ::skgpu::ganesh::AtlasTextOp

friend

Definition at line 79 of file GlyphVector.h.

::skgpu::graphite::Device

friend class ::skgpu::graphite::Device

friend

Definition at line 78 of file GlyphVector.h.

GlyphVectorTestingPeer

friend class GlyphVectorTestingPeer

friend

Definition at line 77 of file GlyphVector.h.

---

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

• third_party/skia/src/text/gpu/GlyphVector.h
• third_party/skia/src/gpu/ganesh/text/GrAtlasManager.cpp
• third_party/skia/src/gpu/graphite/text/TextAtlasManager.cpp
• third_party/skia/src/text/gpu/GlyphVector.cpp