SkGlyph Class Reference

#include <SkGlyph.h>

Public Member Functions
constexpr	SkGlyph ()
	SkGlyph (const SkGlyph &)
SkGlyph &	operator= (const SkGlyph &)
	SkGlyph (SkGlyph &&)
SkGlyph &	operator= (SkGlyph &&)
	~SkGlyph ()
constexpr	SkGlyph (SkPackedGlyphID id)
SkVector	advanceVector () const
SkScalar	advanceX () const
SkScalar	advanceY () const
SkGlyphID	getGlyphID () const
SkPackedGlyphID	getPackedID () const
SkFixed	getSubXFixed () const
SkFixed	getSubYFixed () const
size_t	rowBytes () const
size_t	rowBytesUsingFormat (SkMask::Format format) const
void	zeroMetrics ()
SkMask	mask () const
SkMask	mask (SkPoint position) const
bool	setImage (SkArenaAlloc *alloc, SkScalerContext *scalerContext)
bool	setImage (SkArenaAlloc *alloc, const void *image)
size_t	setMetricsAndImage (SkArenaAlloc *alloc, const SkGlyph &from)
bool	setImageHasBeenCalled () const
const void *	image () const
size_t	imageSize () const
bool	setPath (SkArenaAlloc *alloc, SkScalerContext *scalerContext)
bool	setPath (SkArenaAlloc *alloc, const SkPath *path, bool hairline)
bool	setPathHasBeenCalled () const
const SkPath *	path () const
bool	pathIsHairline () const
bool	setDrawable (SkArenaAlloc *alloc, SkScalerContext *scalerContext)
bool	setDrawable (SkArenaAlloc *alloc, sk_sp< SkDrawable > drawable)
bool	setDrawableHasBeenCalled () const
SkDrawable *	drawable () const
bool	isColor () const
SkMask::Format	maskFormat () const
size_t	formatAlignment () const
int	maxDimension () const
SkIRect	iRect () const
SkRect	rect () const
SkGlyphRect	glyphRect () const
int	left () const
int	top () const
int	width () const
int	height () const
bool	isEmpty () const
bool	imageTooLarge () const
uint16_t	extraBits () const
void	ensureIntercepts (const SkScalar bounds[2], SkScalar scale, SkScalar xPos, SkScalar *array, int *count, SkArenaAlloc *alloc)
void	setImage (void *image)
void	flattenMetrics (SkWriteBuffer &) const
void	flattenImage (SkWriteBuffer &) const
size_t	addImageFromBuffer (SkReadBuffer &, SkArenaAlloc *)
void	flattenPath (SkWriteBuffer &) const
size_t	addPathFromBuffer (SkReadBuffer &, SkArenaAlloc *)
void	flattenDrawable (SkWriteBuffer &) const
size_t	addDrawableFromBuffer (SkReadBuffer &, SkArenaAlloc *)

Static Public Member Functions
static std::optional< SkGlyph >	MakeFromBuffer (SkReadBuffer &)

Friends
class	SkScalerContext
class	SkGlyphTestPeer

Detailed Description

Definition at line 413 of file SkGlyph.h.

Constructor & Destructor Documentation

SkGlyph() [1/4]

constexpr SkGlyph::SkGlyph ( )

inlineconstexpr

Definition at line 417 of file SkGlyph.h.

: SkGlyph{SkPackedGlyphID()} { }

SkGlyph() [2/4]

SkGlyph::SkGlyph ( const SkGlyph &  )

default

SkGlyph() [3/4]

SkGlyph::SkGlyph ( SkGlyph &&  )

default

~SkGlyph()

SkGlyph::~SkGlyph ( )

default

SkGlyph() [4/4]

constexpr SkGlyph::SkGlyph ( SkPackedGlyphID  id )

inlineexplicitconstexpr

Definition at line 423 of file SkGlyph.h.

: fID{id} { }

Member Function Documentation

addDrawableFromBuffer()

size_t SkGlyph::addDrawableFromBuffer	(	SkReadBuffer &	buffer,
		SkArenaAlloc *	alloc
	)

Definition at line 425 of file SkGlyph.cpp.

                                                                               {
    SkASSERT(buffer.isValid());
 
    sk_sp<SkDrawable> drawable = SkPictureBackedGlyphDrawable::MakeFromBuffer(buffer);
    if (!buffer.isValid()) {
        return 0;
    }
 
    if (this->setDrawable(alloc, std::move(drawable))) {
        return this->drawable()->approximateBytesUsed();
    }
 
    return 0;
}

addImageFromBuffer()

size_t SkGlyph::addImageFromBuffer	(	SkReadBuffer &	buffer,
		SkArenaAlloc *	alloc
	)

Definition at line 358 of file SkGlyph.cpp.

                                                                            {
    SkASSERT(buffer.isValid());
 
    // If the glyph is empty or too big, then no image data is received.
    if (this->isEmpty() || !SkGlyphDigest::FitsInAtlas(*this)) {
        return 0;
    }
 
    size_t memoryIncrease = 0;
 
    void* imageData = alloc->makeBytesAlignedTo(this->imageSize(), this->formatAlignment());
    buffer.readByteArray(imageData, this->imageSize());
    if (buffer.isValid()) {
        this->installImage(imageData);
        memoryIncrease += this->imageSize();
    }
 
    return memoryIncrease;
}

addPathFromBuffer()

size_t SkGlyph::addPathFromBuffer	(	SkReadBuffer &	buffer,
		SkArenaAlloc *	alloc
	)

Definition at line 389 of file SkGlyph.cpp.

                                                                           {
    SkASSERT(buffer.isValid());
 
    size_t memoryIncrease = 0;
    const bool hasPath = buffer.readBool();
    // Check if the buffer is invalid, so as to not make a logical decision on invalid data.
    if (!buffer.isValid()) {
        return 0;
    }
    if (hasPath) {
        const bool pathIsHairline = buffer.readBool();
        SkPath path;
        buffer.readPath(&path);
        if (buffer.isValid()) {
            if (this->setPath(alloc, &path, pathIsHairline)) {
                memoryIncrease += path.approximateBytesUsed();
            }
        }
    } else {
        this->setPath(alloc, nullptr, false);
    }
 
    return memoryIncrease;
}

advanceVector()

SkVector SkGlyph::advanceVector ( ) const

inline

Definition at line 425 of file SkGlyph.h.

{ return SkVector{fAdvanceX, fAdvanceY}; }

advanceX()

SkScalar SkGlyph::advanceX ( ) const

inline

Definition at line 426 of file SkGlyph.h.

{ return fAdvanceX; }

advanceY()

SkScalar SkGlyph::advanceY ( ) const

inline

Definition at line 427 of file SkGlyph.h.

{ return fAdvanceY; }

drawable()

SkDrawable * SkGlyph::drawable

(

)

const

Definition at line 327 of file SkGlyph.cpp.

                                    {
    // setDrawable must have been called previously.
    SkASSERT(this->setDrawableHasBeenCalled());
    if (fDrawableData->fHasDrawable) {
        return fDrawableData->fDrawable.get();
    }
    return nullptr;
}

ensureIntercepts()

void SkGlyph::ensureIntercepts	(	const SkScalar	bounds[2],
		SkScalar	scale,
		SkScalar	xPos,
		SkScalar *	array,
		int *	count,
		SkArenaAlloc *	alloc
	)

Definition at line 547 of file SkGlyph.cpp.

                                                                                 {
 
    auto offsetResults = [scale, xPos](
            const SkGlyph::Intercept* intercept,SkScalar* array, int* count) {
        if (array) {
            array += *count;
            for (int index = 0; index < 2; index++) {
                *array++ = intercept->fInterval[index] * scale + xPos;
            }
        }
        *count += 2;
    };
 
    const SkGlyph::Intercept* match =
            [this](const SkScalar bounds[2]) -> const SkGlyph::Intercept* {
                if (fPathData == nullptr) {
                    return nullptr;
                }
                const SkGlyph::Intercept* intercept = fPathData->fIntercept;
                while (intercept != nullptr) {
                    if (bounds[0] == intercept->fBounds[0] && bounds[1] == intercept->fBounds[1]) {
                        return intercept;
                    }
                    intercept = intercept->fNext;
                }
                return nullptr;
            }(bounds);
 
    if (match != nullptr) {
        if (match->fInterval[0] < match->fInterval[1]) {
            offsetResults(match, array, count);
        }
        return;
    }
 
    SkGlyph::Intercept* intercept = alloc->make<SkGlyph::Intercept>();
    intercept->fNext = fPathData->fIntercept;
    intercept->fBounds[0] = bounds[0];
    intercept->fBounds[1] = bounds[1];
    intercept->fInterval[0] = SK_ScalarMax;
    intercept->fInterval[1] = SK_ScalarMin;
    fPathData->fIntercept = intercept;
    const SkPath* path = &(fPathData->fPath);
    const SkRect& pathBounds = path->getBounds();
    if (pathBounds.fBottom < bounds[0] || bounds[1] < pathBounds.fTop) {
        return;
    }
 
    std::tie(intercept->fInterval[0], intercept->fInterval[1])
            = calculate_path_gap(bounds[0], bounds[1], *path);
 
    if (intercept->fInterval[0] >= intercept->fInterval[1]) {
        intercept->fInterval[0] = SK_ScalarMax;
        intercept->fInterval[1] = SK_ScalarMin;
        return;
    }
    offsetResults(intercept, array, count);
}

extraBits()

uint16_t SkGlyph::extraBits ( ) const

inline

Definition at line 519 of file SkGlyph.h.

{ return fScalerContextBits; }

flattenDrawable()

void SkGlyph::flattenDrawable

(

SkWriteBuffer &

buffer

)

const

Definition at line 414 of file SkGlyph.cpp.

                                                         {
    SkASSERT(this->setDrawableHasBeenCalled());
 
    if (this->isEmpty() || this->drawable() == nullptr) {
        SkPictureBackedGlyphDrawable::FlattenDrawable(buffer, nullptr);
        return;
    }
 
    SkPictureBackedGlyphDrawable::FlattenDrawable(buffer, this->drawable());
}

flattenImage()

void SkGlyph::flattenImage

(

SkWriteBuffer &

buffer

)

const

Definition at line 349 of file SkGlyph.cpp.

                                                      {
    SkASSERT(this->setImageHasBeenCalled());
 
    // If the glyph is empty or too big, then no image data is sent.
    if (!this->isEmpty() && SkGlyphDigest::FitsInAtlas(*this)) {
        buffer.writeByteArray(this->image(), this->imageSize());
    }
}

flattenMetrics()

void SkGlyph::flattenMetrics

(

SkWriteBuffer &

buffer

)

const

Definition at line 336 of file SkGlyph.cpp.

                                                        {
    buffer.writeUInt(fID.value());
    buffer.writePoint({fAdvanceX, fAdvanceY});
    buffer.writeUInt(fWidth << 16 | fHeight);
    // Note: << has undefined behavior for negative values, so convert everything to the bit
    // values of uint16_t. Using the cast keeps the signed values fLeft and fTop from sign
    // extending.
    const uint32_t left = static_cast<uint16_t>(fLeft);
    const uint32_t top = static_cast<uint16_t>(fTop);
    buffer.writeUInt(left << 16 | top);
    buffer.writeUInt(SkTo<uint32_t>(fMaskFormat));
}

flattenPath()

void SkGlyph::flattenPath

(

SkWriteBuffer &

buffer

)

const

Definition at line 378 of file SkGlyph.cpp.

                                                     {
    SkASSERT(this->setPathHasBeenCalled());
 
    const bool hasPath = this->path() != nullptr;
    buffer.writeBool(hasPath);
    if (hasPath) {
        buffer.writeBool(this->pathIsHairline());
        buffer.writePath(*this->path());
    }
}

formatAlignment()

size_t SkGlyph::formatAlignment

(

)

const

Definition at line 173 of file SkGlyph.cpp.

                                      {
    return format_alignment(this->maskFormat());
}

getGlyphID()

SkGlyphID SkGlyph::getGlyphID ( ) const

inline

Definition at line 429 of file SkGlyph.h.

{ return fID.glyphID(); }

getPackedID()

SkPackedGlyphID SkGlyph::getPackedID ( ) const

inline

Definition at line 430 of file SkGlyph.h.

{ return fID; }

getSubXFixed()

SkFixed SkGlyph::getSubXFixed ( ) const

inline

Definition at line 431 of file SkGlyph.h.

{ return fID.getSubXFixed(); }

getSubYFixed()

SkFixed SkGlyph::getSubYFixed ( ) const

inline

Definition at line 432 of file SkGlyph.h.

{ return fID.getSubYFixed(); }

glyphRect()

SkGlyphRect SkGlyph::glyphRect ( ) const

inline

Definition at line 507 of file SkGlyph.h.

                                  {
        return SkGlyphRect(fLeft, fTop, fLeft + fWidth, fTop + fHeight);
    }

height()

int SkGlyph::height ( ) const

inline

Definition at line 513 of file SkGlyph.h.

{ return fHeight; }

image()

const void * SkGlyph::image ( ) const

inline

Definition at line 465 of file SkGlyph.h.

{ SkASSERT(this->setImageHasBeenCalled()); return fImage; }

imageSize()

size_t SkGlyph::imageSize

(

)

const

Definition at line 241 of file SkGlyph.cpp.

                                {
    if (this->isEmpty() || this->imageTooLarge()) { return 0; }
 
    size_t size = this->rowBytes() * fHeight;
 
    if (fMaskFormat == SkMask::k3D_Format) {
        size *= 3;
    }
 
    return size;
}

imageTooLarge()

bool SkGlyph::imageTooLarge ( ) const

inline

Definition at line 517 of file SkGlyph.h.

{ return fWidth >= kMaxGlyphWidth; }

iRect()

SkIRect SkGlyph::iRect ( ) const

inline

Definition at line 505 of file SkGlyph.h.

{ return SkIRect::MakeXYWH(fLeft, fTop, fWidth, fHeight); }

isColor()

bool SkGlyph::isColor ( ) const

inline

Definition at line 499 of file SkGlyph.h.

{ return fMaskFormat == SkMask::kARGB32_Format; }

isEmpty()

bool SkGlyph::isEmpty ( ) const

inline

Definition at line 514 of file SkGlyph.h.

                         {
        return fWidth == 0 || fHeight == 0;
    }

left()

int SkGlyph::left ( ) const

inline

Definition at line 510 of file SkGlyph.h.

{ return fLeft;   }

MakeFromBuffer()

std::optional< SkGlyph > SkGlyph::MakeFromBuffer ( SkReadBuffer &  buffer )

static

Definition at line 95 of file SkGlyph.cpp.

                                                                 {
    SkASSERT(buffer.isValid());
    const SkPackedGlyphID packedID{buffer.readUInt()};
    const SkVector advance = buffer.readPoint();
    const uint32_t dimensions = buffer.readUInt();
    const uint32_t leftTop = buffer.readUInt();
    const SkMask::Format format = SkTo<SkMask::Format>(buffer.readUInt());
 
    if (!buffer.validate(SkMask::IsValidFormat(format))) {
        return std::nullopt;
    }
 
    SkGlyph glyph{packedID};
    glyph.fAdvanceX = advance.x();
    glyph.fAdvanceY = advance.y();
    glyph.fWidth = dimensions >> 16;
    glyph.fHeight = dimensions & 0xffffu;
    glyph.fLeft = leftTop >> 16;
    glyph.fTop = leftTop & 0xffffu;
    glyph.fMaskFormat = format;
    SkDEBUGCODE(glyph.fAdvancesBoundsFormatAndInitialPathDone = true;)
    return glyph;
}

mask() [1/2]

SkMask SkGlyph::mask

(

)

const

Definition at line 125 of file SkGlyph.cpp.

                           {
    SkIRect bounds = SkIRect::MakeXYWH(fLeft, fTop, fWidth, fHeight);
    return SkMask(static_cast<const uint8_t*>(fImage), bounds, this->rowBytes(), fMaskFormat);
}

mask() [2/2]

SkMask SkGlyph::mask

(

SkPoint

position

)

const

Definition at line 130 of file SkGlyph.cpp.

                                           {
    SkASSERT(SkScalarIsInt(position.x()) && SkScalarIsInt(position.y()));
    SkIRect bounds = SkIRect::MakeXYWH(fLeft, fTop, fWidth, fHeight);
    bounds.offset(SkScalarFloorToInt(position.x()), SkScalarFloorToInt(position.y()));
    return SkMask(static_cast<const uint8_t*>(fImage), bounds, this->rowBytes(), fMaskFormat);
}

maskFormat()

SkMask::Format SkGlyph::maskFormat ( ) const

inline

Definition at line 500 of file SkGlyph.h.

{ return fMaskFormat; }

maxDimension()

int SkGlyph::maxDimension ( ) const

inline

Definition at line 504 of file SkGlyph.h.

{ return std::max(fWidth, fHeight); }

operator=() [1/2]

SkGlyph & SkGlyph::operator= ( const SkGlyph &  )

default

operator=() [2/2]

SkGlyph & SkGlyph::operator= ( SkGlyph &&  )

default

path()

const SkPath * SkGlyph::path

(

)

const

Definition at line 284 of file SkGlyph.cpp.

                                  {
    // setPath must have been called previously.
    SkASSERT(this->setPathHasBeenCalled());
    if (fPathData->fHasPath) {
        return &fPathData->fPath;
    }
    return nullptr;
}

pathIsHairline()

bool SkGlyph::pathIsHairline

(

)

const

Definition at line 293 of file SkGlyph.cpp.

                                   {
    // setPath must have been called previously.
    SkASSERT(this->setPathHasBeenCalled());
    return fPathData->fHairline;
}

rect()

SkRect SkGlyph::rect ( ) const

inline

Definition at line 506 of file SkGlyph.h.

{ return SkRect::MakeXYWH(fLeft, fTop, fWidth, fHeight);  }

rowBytes()

size_t SkGlyph::rowBytes

(

)

const

Definition at line 233 of file SkGlyph.cpp.

                               {
    return format_rowbytes(fWidth, fMaskFormat);
}

rowBytesUsingFormat()

size_t SkGlyph::rowBytesUsingFormat

(

SkMask::Format

format

)

const

Definition at line 237 of file SkGlyph.cpp.

                                                             {
    return format_rowbytes(fWidth, format);
}

setDrawable() [1/2]

bool SkGlyph::setDrawable	(	SkArenaAlloc *	alloc,
		sk_sp< SkDrawable >	drawable
	)

Definition at line 319 of file SkGlyph.cpp.

                                                                         {
    if (!this->setDrawableHasBeenCalled()) {
        this->installDrawable(alloc, std::move(drawable));
        return this->drawable() != nullptr;
    }
    return false;
}

setDrawable() [2/2]

bool SkGlyph::setDrawable	(	SkArenaAlloc *	alloc,
		SkScalerContext *	scalerContext
	)

Definition at line 310 of file SkGlyph.cpp.

                                                                             {
    if (!this->setDrawableHasBeenCalled()) {
        sk_sp<SkDrawable> drawable = scalerContext->getDrawable(*this);
        this->installDrawable(alloc, std::move(drawable));
        return this->drawable() != nullptr;
    }
    return false;
}

setDrawableHasBeenCalled()

bool SkGlyph::setDrawableHasBeenCalled ( ) const

inline

Definition at line 495 of file SkGlyph.h.

{ return fDrawableData != nullptr; }

setImage() [1/3]

bool SkGlyph::setImage	(	SkArenaAlloc *	alloc,
		const void *	image
	)

Definition at line 198 of file SkGlyph.cpp.

                                                             {
    if (!this->setImageHasBeenCalled()) {
        this->allocImage(alloc);
        memcpy(fImage, image, this->imageSize());
        return true;
    }
    return false;
}

setImage() [2/3]

bool SkGlyph::setImage	(	SkArenaAlloc *	alloc,
		SkScalerContext *	scalerContext
	)

Definition at line 185 of file SkGlyph.cpp.

                                                                          {
    if (!this->setImageHasBeenCalled()) {
        // It used to be that getImage() could change the fMaskFormat. Extra checking to make
        // sure there are no regressions.
        SkDEBUGCODE(SkMask::Format oldFormat = this->maskFormat());
        this->allocImage(alloc);
        scalerContext->getImage(*this);
        SkASSERT(oldFormat == this->maskFormat());
        return true;
    }
    return false;
}

setImage() [3/3]

void SkGlyph::setImage ( void *  image )

inline

Definition at line 531 of file SkGlyph.h.

{ fImage = image; }

setImageHasBeenCalled()

bool SkGlyph::setImageHasBeenCalled ( ) const

inline

Definition at line 459 of file SkGlyph.h.

                                       {
        // Check for empty bounds first to guard against fImage somehow being set.
        return this->isEmpty() || fImage != nullptr || this->imageTooLarge();
    }

setMetricsAndImage()

size_t SkGlyph::setMetricsAndImage	(	SkArenaAlloc *	alloc,
		const SkGlyph &	from
	)

Definition at line 207 of file SkGlyph.cpp.

                                                                           {
    // Since the code no longer tries to find replacement glyphs, the image should always be
    // nullptr.
    SkASSERT(fImage == nullptr || from.fImage == nullptr);
 
    // TODO(herb): remove "if" when we are sure there are no colliding glyphs.
    if (fImage == nullptr) {
        fAdvanceX = from.fAdvanceX;
        fAdvanceY = from.fAdvanceY;
        fWidth = from.fWidth;
        fHeight = from.fHeight;
        fTop = from.fTop;
        fLeft = from.fLeft;
        fScalerContextBits = from.fScalerContextBits;
        fMaskFormat = from.fMaskFormat;
 
        // From glyph may not have an image because the glyph is too large.
        if (from.fImage != nullptr && this->setImage(alloc, from.image())) {
            return this->imageSize();
        }
 
        SkDEBUGCODE(fAdvancesBoundsFormatAndInitialPathDone = from.fAdvancesBoundsFormatAndInitialPathDone;)
    }
    return 0;
}

setPath() [1/2]

bool SkGlyph::setPath	(	SkArenaAlloc *	alloc,
		const SkPath *	path,
		bool	hairline
	)

Definition at line 276 of file SkGlyph.cpp.

                                                                            {
    if (!this->setPathHasBeenCalled()) {
        this->installPath(alloc, path, hairline);
        return this->path() != nullptr;
    }
    return false;
}

setPath() [2/2]

bool SkGlyph::setPath	(	SkArenaAlloc *	alloc,
		SkScalerContext *	scalerContext
	)

Definition at line 266 of file SkGlyph.cpp.

                                                                         {
    if (!this->setPathHasBeenCalled()) {
        scalerContext->getPath(*this, alloc);
        SkASSERT(this->setPathHasBeenCalled());
        return this->path() != nullptr;
    }
 
    return false;
}

setPathHasBeenCalled()

bool SkGlyph::setPathHasBeenCalled ( ) const

inline

Definition at line 486 of file SkGlyph.h.

{ return fPathData != nullptr; }

top()

int SkGlyph::top ( ) const

inline

Definition at line 511 of file SkGlyph.h.

{ return fTop;    }

width()

int SkGlyph::width ( ) const

inline

Definition at line 512 of file SkGlyph.h.

{ return fWidth;  }

zeroMetrics()

void SkGlyph::zeroMetrics

(

)

Definition at line 137 of file SkGlyph.cpp.

                          {
    fAdvanceX = 0;
    fAdvanceY = 0;
    fWidth    = 0;
    fHeight   = 0;
    fTop      = 0;
    fLeft     = 0;
}

Friends And Related Function Documentation

SkGlyphTestPeer

friend class SkGlyphTestPeer

friend

Definition at line 561 of file SkGlyph.h.

SkScalerContext

friend class SkScalerContext

friend

Definition at line 560 of file SkGlyph.h.

---

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

• third_party/skia/src/core/SkGlyph.h
• third_party/skia/src/core/SkGlyph.cpp