SkFontationsScalerContext Class Reference

Inheritance diagram for SkFontationsScalerContext:

Classes
struct	ScalerContextBits

Public Member Functions
	SkFontationsScalerContext (sk_sp< SkTypeface_Fontations > face, const SkScalerContextEffects &effects, const SkDescriptor *desc)
bool	generateYScalePathForGlyphId (uint16_t glyphId, SkPath *path, float yScale)
Public Member Functions inherited from SkScalerContext
	SkScalerContext (sk_sp< SkTypeface >, const SkScalerContextEffects &, const SkDescriptor *)
virtual	~SkScalerContext ()
SkTypeface *	getTypeface () const
SkMask::Format	getMaskFormat () const
bool	isSubpixel () const
bool	isLinearMetrics () const
bool	isVertical () const
SkGlyph	makeGlyph (SkPackedGlyphID, SkArenaAlloc *)
void	getImage (const SkGlyph &)
void	getPath (SkGlyph &, SkArenaAlloc *)
sk_sp< SkDrawable >	getDrawable (SkGlyph &)
void	getFontMetrics (SkFontMetrics *)
const SkScalerContextRec &	getRec () const
SkScalerContextEffects	getEffects () const
SkAxisAlignment	computeAxisAlignmentForHText () const

Protected Member Functions
GlyphMetrics	generateMetrics (const SkGlyph &glyph, SkArenaAlloc *) override
void	generatePngImage (const SkGlyph &glyph, void *imageBuffer)
void	generateImage (const SkGlyph &glyph, void *imageBuffer) override
bool	generatePath (const SkGlyph &glyph, SkPath *path) override
bool	drawCOLRGlyph (const SkGlyph &glyph, SkColor foregroundColor, SkCanvas *canvas)
sk_sp< SkDrawable >	generateDrawable (const SkGlyph &glyph) override
void	generateFontMetrics (SkFontMetrics *out_metrics) override
Protected Member Functions inherited from SkScalerContext
void	forceGenerateImageFromPath ()
void	forceOffGenerateImageFromPath ()

Friends
class	sk_fontations::ColorPainter

Additional Inherited Members
Public Types inherited from SkScalerContext
enum	Flags {   kFrameAndFill_Flag = 0x0001 , kUnused = 0x0002 , kEmbeddedBitmapText_Flag = 0x0004 , kEmbolden_Flag = 0x0008 ,   kSubpixelPositioning_Flag = 0x0010 , kForceAutohinting_Flag = 0x0020 , kHinting_Shift = 7 , kHintingBit1_Flag = 0x0080 ,   kHintingBit2_Flag = 0x0100 , kLCD_Vertical_Flag = 0x0200 , kLCD_BGROrder_Flag = 0x0400 , kGenA8FromLCD_Flag = 0x0800 ,   kLinearMetrics_Flag = 0x1000 , kBaselineSnap_Flag = 0x2000 , kNeedsForegroundColor_Flag = 0x4000 }
enum	{ kHinting_Mask = kHintingBit1_Flag | kHintingBit2_Flag }
Static Public Member Functions inherited from SkScalerContext
static size_t	GetGammaLUTSize (SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma, int *width, int *height)
static bool	GetGammaLUTData (SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma, uint8_t *data)
static void	MakeRecAndEffects (const SkFont &font, const SkPaint &paint, const SkSurfaceProps &surfaceProps, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkScalerContextRec *rec, SkScalerContextEffects *effects)
static void	MakeRecAndEffectsFromFont (const SkFont &font, SkScalerContextRec *rec, SkScalerContextEffects *effects)
static std::unique_ptr< SkScalerContext >	MakeEmpty (sk_sp< SkTypeface > typeface, const SkScalerContextEffects &effects, const SkDescriptor *desc)
static SkDescriptor *	AutoDescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, SkAutoDescriptor *ad)
static std::unique_ptr< SkDescriptor >	DescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects)
static void	DescriptorBufferGiveRec (const SkScalerContextRec &rec, void *buffer)
static bool	CheckBufferSizeForRec (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, size_t size)
static SkMaskGamma::PreBlend	GetMaskPreBlend (const SkScalerContextRec &rec)
static SkDescriptor *	CreateDescriptorAndEffectsUsingPaint (const SkFont &, const SkPaint &, const SkSurfaceProps &, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkAutoDescriptor *ad, SkScalerContextEffects *effects)
Static Protected Member Functions inherited from SkScalerContext
static void	GenerateMetricsFromPath (SkGlyph *glyph, const SkPath &path, SkMask::Format format, bool verticalLCD, bool a8FromLCD, bool hairline)
static void	SaturateGlyphBounds (SkGlyph *glyph, SkRect &&)
static void	SaturateGlyphBounds (SkGlyph *glyph, SkIRect const &)
static void	GenerateImageFromPath (SkMaskBuilder &dst, const SkPath &path, const SkMaskGamma::PreBlend &maskPreBlend, bool doBGR, bool verticalLCD, bool a8FromLCD, bool hairline)
Protected Attributes inherited from SkScalerContext
SkScalerContextRec	fRec
const SkMaskGamma::PreBlend	fPreBlend

Detailed Description

Definition at line 334 of file SkTypeface_fontations.cpp.

Constructor & Destructor Documentation

SkFontationsScalerContext()

SkFontationsScalerContext::SkFontationsScalerContext ( sk_sp< SkTypeface_Fontations >  face, const SkScalerContextEffects &  effects, const SkDescriptor *  desc  )

inline

Definition at line 336 of file SkTypeface_fontations.cpp.

            : SkScalerContext(face, effects, desc)
            , fBridgeFontRef(
                      static_cast<SkTypeface_Fontations*>(this->getTypeface())->getBridgeFontRef())
            , fBridgeNormalizedCoords(static_cast<SkTypeface_Fontations*>(this->getTypeface())
                                              ->getBridgeNormalizedCoords())
            , fOutlines(static_cast<SkTypeface_Fontations*>(this->getTypeface())->getOutlines())
            , fPalette(static_cast<SkTypeface_Fontations*>(this->getTypeface())->getPalette()) {
        fRec.getSingleMatrix(&fMatrix);
    }

Member Function Documentation

drawCOLRGlyph()

bool SkFontationsScalerContext::drawCOLRGlyph ( const SkGlyph &  glyph, SkColor  foregroundColor, SkCanvas *  canvas  )

inlineprotected

Definition at line 652 of file SkTypeface_fontations.cpp.

                                                                                        {
        uint16_t upem = fontations_ffi::units_per_em_or_zero(fBridgeFontRef);
        if (upem == 0) {
            return false;
        }
 
        SkMatrix scalerMatrix;
        fRec.getSingleMatrix(&scalerMatrix);
        SkAutoCanvasRestore autoRestore(canvas, true /* doSave */);
 
        // Scale down so that COLR operations can happen in glyph coordinates.
        SkMatrix upemToPpem = SkMatrix::Scale(1.f / upem, 1.f / upem);
        scalerMatrix.preConcat(upemToPpem);
        canvas->concat(scalerMatrix);
        SkPaint defaultPaint;
        defaultPaint.setColor(SK_ColorRED);
        sk_fontations::ColorPainter colorPainter(*this, *canvas, fPalette, foregroundColor,
                                                 SkMask::kBW_Format != fRec.fMaskFormat, upem);
        bool result = fontations_ffi::draw_colr_glyph(
                fBridgeFontRef, fBridgeNormalizedCoords, glyph.getGlyphID(), colorPainter);
        return result;
    }

generateDrawable()

sk_sp< SkDrawable > SkFontationsScalerContext::generateDrawable ( const SkGlyph &  )

inlineoverrideprotectedvirtual

Returns the drawable for the glyph (if any).

The generated drawable will be lifetime scoped to the lifetime of this scaler context. This means the drawable may refer to the scaler context and associated font data.

The drawable does not need to be flattenable (e.g. implement getFactory and getTypeName). Any necessary serialization will be done with makePictureSnapshot.

Reimplemented from SkScalerContext.

Definition at line 675 of file SkTypeface_fontations.cpp.

                                                                      {
        struct GlyphDrawable : public SkDrawable {
            SkFontationsScalerContext* fSelf;
            SkGlyph fGlyph;
            GlyphDrawable(SkFontationsScalerContext* self, const SkGlyph& glyph)
                    : fSelf(self), fGlyph(glyph) {}
            SkRect onGetBounds() override { return fGlyph.rect(); }
            size_t onApproximateBytesUsed() override { return sizeof(GlyphDrawable); }
            void maybeShowTextBlitCoverage(SkCanvas* canvas) {
                if constexpr (kSkShowTextBlitCoverage) {
                    SkPaint paint;
                    paint.setColor(0x3300FF00);
                    paint.setStyle(SkPaint::kFill_Style);
                    canvas->drawRect(this->onGetBounds(), paint);
                }
            }
        };
        struct ColrGlyphDrawable : public GlyphDrawable {
            using GlyphDrawable::GlyphDrawable;
            void onDraw(SkCanvas* canvas) override {
                this->maybeShowTextBlitCoverage(canvas);
                fSelf->drawCOLRGlyph(fGlyph, fSelf->fRec.fForegroundColor, canvas);
            }
        };
        ScalerContextBits::value_type format = glyph.extraBits();
        if (format == ScalerContextBits::COLRv1 || format == ScalerContextBits::COLRv0) {
            return sk_sp<SkDrawable>(new ColrGlyphDrawable(this, glyph));
        }
        return nullptr;
    }

generateFontMetrics()

void SkFontationsScalerContext::generateFontMetrics ( SkFontMetrics *  )

inlineoverrideprotectedvirtual

Retrieves font metrics.

Implements SkScalerContext.

Definition at line 706 of file SkTypeface_fontations.cpp.

                                                                  {
        SkVector scale;
        SkMatrix remainingMatrix;
        fRec.computeMatrices(
                SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix);
        fontations_ffi::Metrics metrics =
                fontations_ffi::get_skia_metrics(fBridgeFontRef, scale.fY, fBridgeNormalizedCoords);
        out_metrics->fTop = -metrics.top;
        out_metrics->fAscent = -metrics.ascent;
        out_metrics->fDescent = -metrics.descent;
        out_metrics->fBottom = -metrics.bottom;
        out_metrics->fLeading = metrics.leading;
        out_metrics->fAvgCharWidth = metrics.avg_char_width;
        out_metrics->fMaxCharWidth = metrics.max_char_width;
        out_metrics->fXMin = metrics.x_min;
        out_metrics->fXMax = metrics.x_max;
        out_metrics->fXHeight = -metrics.x_height;
        out_metrics->fCapHeight = -metrics.cap_height;
        out_metrics->fFlags = 0;
        if (fontations_ffi::table_data(fBridgeFontRef,
                                       SkSetFourByteTag('f', 'v', 'a', 'r'),
                                       0,
                                       rust::Slice<uint8_t>())) {
            out_metrics->fFlags |= SkFontMetrics::kBoundsInvalid_Flag;
        }
        auto setMetric = [](float& dstMetric, const float srcMetric,
                            uint32_t& flags, const SkFontMetrics::FontMetricsFlags flag)
        {
            if (std::isnan(srcMetric)) {
                dstMetric = 0;
            } else {
                dstMetric = srcMetric;
                flags |= flag;
            }
        };
        setMetric(out_metrics->fUnderlinePosition, -metrics.underline_position,
                  out_metrics->fFlags, SkFontMetrics::kUnderlinePositionIsValid_Flag);
        setMetric(out_metrics->fUnderlineThickness, metrics.underline_thickness,
                  out_metrics->fFlags, SkFontMetrics::kUnderlineThicknessIsValid_Flag);
 
        setMetric(out_metrics->fStrikeoutPosition, -metrics.strikeout_position,
                  out_metrics->fFlags, SkFontMetrics::kStrikeoutPositionIsValid_Flag);
        setMetric(out_metrics->fStrikeoutThickness, metrics.strikeout_thickness,
                  out_metrics->fFlags, SkFontMetrics::kStrikeoutThicknessIsValid_Flag);
    }

generateImage()

void SkFontationsScalerContext::generateImage ( const SkGlyph &  glyph, void *  imageBuffer  )

inlineoverrideprotectedvirtual

Generates the contents of glyph.fImage. When called, glyph.fImage will be pointing to a pre-allocated, uninitialized region of memory of size glyph.imageSize(). This method may not change glyph.fMaskFormat.

Because glyph.imageSize() will determine the size of fImage, generateMetrics will be called before generateImage.

Implements SkScalerContext.

Definition at line 593 of file SkTypeface_fontations.cpp.

                                                                         {
        ScalerContextBits::value_type format = glyph.extraBits();
        if (format == ScalerContextBits::PATH) {
            const SkPath* devPath = glyph.path();
            SkASSERT_RELEASE(devPath);
            SkMaskBuilder mask(static_cast<uint8_t*>(imageBuffer),
                               glyph.iRect(),
                               glyph.rowBytes(),
                               glyph.maskFormat());
            SkASSERT(SkMask::kARGB32_Format != mask.fFormat);
            const bool doBGR = SkToBool(fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag);
            const bool doVert = SkToBool(fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag);
            const bool a8LCD = SkToBool(fRec.fFlags & SkScalerContext::kGenA8FromLCD_Flag);
            const bool hairline = glyph.pathIsHairline();
            GenerateImageFromPath(mask, *devPath, fPreBlend, doBGR, doVert, a8LCD, hairline);
 
        } else if (format == ScalerContextBits::COLRv1 || format == ScalerContextBits::COLRv0) {
            SkASSERT(glyph.maskFormat() == SkMask::kARGB32_Format);
            SkBitmap dstBitmap;
            dstBitmap.setInfo(
                    SkImageInfo::Make(
                            glyph.width(), glyph.height(), kN32_SkColorType, kPremul_SkAlphaType),
                    glyph.rowBytes());
            dstBitmap.setPixels(imageBuffer);
 
            SkCanvas canvas(dstBitmap);
            if constexpr (kSkShowTextBlitCoverage) {
                canvas.clear(0x33FF0000);
            } else {
                canvas.clear(SK_ColorTRANSPARENT);
            }
            canvas.translate(-glyph.left(), -glyph.top());
 
            drawCOLRGlyph(glyph, fRec.fForegroundColor, &canvas);
        } else if (format == ScalerContextBits::BITMAP) {
            generatePngImage(glyph, imageBuffer);
        } else {
            SK_ABORT("Bad format");
        }
    }

generateMetrics()

GlyphMetrics SkFontationsScalerContext::generateMetrics ( const SkGlyph &  glyph, SkArenaAlloc *    )

inlineoverrideprotectedvirtual

Implements SkScalerContext.

Definition at line 380 of file SkTypeface_fontations.cpp.

                                                                               {
        GlyphMetrics mx(glyph.maskFormat());
 
        SkVector scale;
        SkMatrix remainingMatrix;
        if (!fRec.computeMatrices(
                    SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix)) {
            return mx;
        }
        float x_advance = 0.0f;
        x_advance = fontations_ffi::advance_width_or_zero(
                fBridgeFontRef, scale.y(), fBridgeNormalizedCoords, glyph.getGlyphID());
        // TODO(drott): y-advance?
        mx.advance = remainingMatrix.mapXY(x_advance, SkFloatToScalar(0.f));
 
        // The FreeType backend has a big switch here:
        // Scalable or bitmap, monochromatic or color, subpixel shifting bounds if needed.
        // For now: check if COLRv1, get clipbox, else -
        // get bounds from Path.
        // TODO(drott): Later move bounds retrieval for monochromatic glyphs to retrieving
        // them from Skrifa scaler, taking hinting into account.
 
        bool has_colrv1_glyph =
                fontations_ffi::has_colrv1_glyph(fBridgeFontRef, glyph.getGlyphID());
        bool has_colrv0_glyph =
                fontations_ffi::has_colrv0_glyph(fBridgeFontRef, glyph.getGlyphID());
        bool has_bitmap_glyph =
                fontations_ffi::has_bitmap_glyph(fBridgeFontRef, glyph.getGlyphID());
 
        if (has_colrv1_glyph || has_colrv0_glyph) {
            mx.extraBits = has_colrv1_glyph ? ScalerContextBits::COLRv1 : ScalerContextBits::COLRv0;
            mx.maskFormat = SkMask::kARGB32_Format;
            mx.neverRequestPath = true;
 
            fontations_ffi::ClipBox clipBox;
            if (has_colrv1_glyph && fontations_ffi::get_colrv1_clip_box(fBridgeFontRef,
                                                                        fBridgeNormalizedCoords,
                                                                        glyph.getGlyphID(),
                                                                        scale.y(),
                                                                        clipBox)) {
                // Flip y.
                SkRect boundsRect = SkRect::MakeLTRB(
                        clipBox.x_min, -clipBox.y_max, clipBox.x_max, -clipBox.y_min);
 
                if (!remainingMatrix.isIdentity()) {
                    SkPath boundsPath = SkPath::Rect(boundsRect);
                    boundsPath.transform(remainingMatrix);
                    boundsRect = boundsPath.getBounds();
                }
 
                boundsRect.roundOut(&mx.bounds);
 
            } else {
                uint16_t upem = fontations_ffi::units_per_em_or_zero(fBridgeFontRef);
                if (upem == 0) {
                    mx.bounds = SkRect::MakeEmpty();
                } else {
                    SkMatrix fullTransform;
                    fRec.getSingleMatrix(&fullTransform);
                    fullTransform.preScale(1.f / upem, 1.f / upem);
 
                    sk_fontations::BoundsPainter boundsPainter(*this, fullTransform, upem);
                    bool result = fontations_ffi::draw_colr_glyph(fBridgeFontRef,
                                                                  fBridgeNormalizedCoords,
                                                                  glyph.getGlyphID(),
                                                                  boundsPainter);
                    if (result) {
                        boundsPainter.getBoundingBox().roundOut(&mx.bounds);
                    } else {
                        mx.bounds = SkRect::MakeEmpty();
                    }
                }
            }
        } else if (has_bitmap_glyph) {
            mx.maskFormat = SkMask::kARGB32_Format;
            mx.neverRequestPath = true;
            mx.extraBits = ScalerContextBits::BITMAP;
 
            rust::cxxbridge1::Box<fontations_ffi::BridgeBitmapGlyph> bitmap_glyph =
                    fontations_ffi::bitmap_glyph(fBridgeFontRef, glyph.getGlyphID(), scale.fY);
            rust::cxxbridge1::Slice<const uint8_t> png_data =
                    fontations_ffi::png_data(*bitmap_glyph);
            SkASSERT(png_data.size());
 
            const fontations_ffi::BitmapMetrics bitmapMetrics =
                    fontations_ffi::bitmap_metrics(*bitmap_glyph);
 
            std::unique_ptr<SkCodec> codec = SkPngDecoder::Decode(
                    SkData::MakeWithoutCopy(png_data.data(), png_data.size()), nullptr);
            if (!codec) {
                return mx;
            }
 
            SkImageInfo info = codec->getInfo();
 
            SkRect bounds = SkRect::Make(info.bounds());
            SkMatrix matrix = remainingMatrix;
 
            // We deal with two scale factors here: Scaling from font units to
            // device pixels, and scaling the embedded PNG from its number of
            // rows to a specific size, depending on the ppem values in the
            // bitmap glyph information.
            SkScalar imageToSize = scale.fY / bitmapMetrics.ppem_y;
            float fontUnitsToSize = scale.fY / fontations_ffi::units_per_em_or_zero(fBridgeFontRef);
 
            // Relevant for sbix only: Convert the potential restrictive size
            // bounds back to unscaled pixels so that it can be intersected with
            // the decompressed pixel size of the sbix image.
            if (!std::isinf(bitmapMetrics.width) && !std::isinf(bitmapMetrics.height)) {
                SkRect modifiedBounds =
                        SkRect::MakeXYWH(0,
                                         0,
                                         bitmapMetrics.width * fontUnitsToSize / imageToSize,
                                         bitmapMetrics.height * fontUnitsToSize / imageToSize);
                if (modifiedBounds.isEmpty()) {
                    bounds = SkRect::MakeEmpty();
                } else {
                    bounds = modifiedBounds;
                }
            }
 
            // The offset from origin is given in font units, so requires a
            // different scale factor than the scaling of the image.
            matrix.preTranslate(bitmapMetrics.bearing_x * fontUnitsToSize,
                                -bitmapMetrics.bearing_y * fontUnitsToSize);
 
            matrix.preScale(imageToSize, imageToSize);
            // For sbix bitmap glyphs, the origin is the bottom left of the image.
            float heightAdjustment =
                    bitmapMetrics.placement_origin_bottom_left ? bounds.height() : 0;
            matrix.preTranslate(0, -heightAdjustment);
 
            if (this->isSubpixel()) {
                matrix.postTranslate(SkFixedToScalar(glyph.getSubXFixed()),
                                     SkFixedToScalar(glyph.getSubYFixed()));
            }
            matrix.mapRect(&bounds);
            mx.bounds = SkRect::Make(bounds.roundOut());
        } else {
            // TODO: Retrieve from read_fonts and Skrifa - TrueType bbox or from path with
            // hinting?
            mx.extraBits = ScalerContextBits::PATH;
            mx.computeFromPath = true;
        }
        return mx;
    }

generatePath()

bool SkFontationsScalerContext::generatePath ( const SkGlyph &  , SkPath *    )

inlineoverrideprotectedvirtual

Sets the passed path to the glyph outline. If this cannot be done the path is set to empty; Does not apply subpixel positioning to the path.

Returns

false if this glyph does not have any path.

Implements SkScalerContext.

Definition at line 634 of file SkTypeface_fontations.cpp.

                                                                   {
        SkASSERT(glyph.extraBits() == ScalerContextBits::PATH);
 
        SkVector scale;
        SkMatrix remainingMatrix;
        if (!fRec.computeMatrices(
                    SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix)) {
            return false;
        }
        bool result = generateYScalePathForGlyphId(glyph.getGlyphID(), path, scale.y());
        if (!result) {
            return false;
        }
 
        *path = path->makeTransform(remainingMatrix);
        return true;
    }

generatePngImage()

void SkFontationsScalerContext::generatePngImage ( const SkGlyph &  glyph, void *  imageBuffer  )

inlineprotected

Definition at line 527 of file SkTypeface_fontations.cpp.

                                                                   {
        SkASSERT(glyph.maskFormat() == SkMask::kARGB32_Format);
        SkBitmap dstBitmap;
        dstBitmap.setInfo(
                SkImageInfo::Make(
                        glyph.width(), glyph.height(), kN32_SkColorType, kPremul_SkAlphaType),
                glyph.rowBytes());
        dstBitmap.setPixels(imageBuffer);
 
        SkCanvas canvas(dstBitmap);
 
        canvas.translate(-glyph.left(), -glyph.top());
 
        SkVector scale;
        SkMatrix remainingMatrix;
        if (!fRec.computeMatrices(
                    SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix)) {
            return;
        }
 
        rust::cxxbridge1::Box<fontations_ffi::BridgeBitmapGlyph> bitmap_glyph =
                fontations_ffi::bitmap_glyph(fBridgeFontRef, glyph.getGlyphID(), scale.fY);
        rust::cxxbridge1::Slice<const uint8_t> png_data = fontations_ffi::png_data(*bitmap_glyph);
        SkASSERT(png_data.size());
 
        std::unique_ptr<SkCodec> codec = SkPngDecoder::Decode(
                SkData::MakeWithoutCopy(png_data.data(), png_data.size()), nullptr);
 
        if (!codec) {
            return;
        }
 
        auto [glyph_image, result] = codec->getImage();
        if (result != SkCodec::Result::kSuccess) {
            return;
        }
 
        canvas.clear(SK_ColorTRANSPARENT);
        canvas.concat(remainingMatrix);
 
        if (this->isSubpixel()) {
            canvas.translate(SkFixedToScalar(glyph.getSubXFixed()),
                             SkFixedToScalar(glyph.getSubYFixed()));
        }
        const fontations_ffi::BitmapMetrics bitmapMetrics =
                fontations_ffi::bitmap_metrics(*bitmap_glyph);
 
        // We need two different scale factors here, one for font units to size,
        // one for scaling the embedded PNG, see generateMetrics() for details.
        SkScalar imageScaleFactor = scale.fY / bitmapMetrics.ppem_y;
 
        float fontUnitsToSize = scale.fY / fontations_ffi::units_per_em_or_zero(fBridgeFontRef);
        canvas.translate(bitmapMetrics.bearing_x * fontUnitsToSize,
                         -bitmapMetrics.bearing_y * fontUnitsToSize);
        canvas.scale(imageScaleFactor, imageScaleFactor);
        canvas.translate(bitmapMetrics.inner_bearing_x, -bitmapMetrics.inner_bearing_y);
 
        float heightAdjustment =
                bitmapMetrics.placement_origin_bottom_left ? glyph_image->height() : 0;
 
        canvas.translate(0, -heightAdjustment);
 
        SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kNearest);
        canvas.drawImage(glyph_image, 0, 0, sampling);
    }

generateYScalePathForGlyphId()

bool SkFontationsScalerContext::generateYScalePathForGlyphId ( uint16_t  glyphId, SkPath *  path, float  yScale  )

inline

Definition at line 350 of file SkTypeface_fontations.cpp.

                                                                                    {
        sk_fontations::PathGeometrySink pathWrapper;
        fontations_ffi::BridgeScalerMetrics scalerMetrics;
 
        if (!fontations_ffi::get_path(fOutlines,
                                      glyphId,
                                      yScale,
                                      fBridgeNormalizedCoords,
                                      pathWrapper,
                                      scalerMetrics)) {
            return false;
        }
        *path = std::move(pathWrapper).into_inner();
        if (scalerMetrics.has_overlaps) {
            // See SkScalerContext_FreeType_Base::generateGlyphPath.
            Simplify(*path, path);
            AsWinding(*path, path);
        }
        return true;
    }

Friends And Related Symbol Documentation

sk_fontations::ColorPainter

friend class sk_fontations::ColorPainter

friend

Definition at line 759 of file SkTypeface_fontations.cpp.

---

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

• third_party/skia/src/ports/SkTypeface_fontations.cpp