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, const fontations_ffi::BridgeHintingInstance &hintingInstance)
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
virtual GlyphMetrics	generateMetrics (const SkGlyph &, SkArenaAlloc *)=0
virtual void	generateImage (const SkGlyph &glyph, void *imageBuffer)=0
virtual bool	generatePath (const SkGlyph &, SkPath *)=0
virtual sk_sp< SkDrawable >	generateDrawable (const SkGlyph &)
virtual void	generateFontMetrics (SkFontMetrics *)=0
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 deviceGamma, int *width, int *height)
static bool	GetGammaLUTData (SkScalar contrast, 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 354 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 356 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())
            , fHintingInstance(fontations_ffi::no_hinting_instance()) {
        fRec.getSingleMatrix(&fMatrix);
 
        SkVector scale;
        SkMatrix remainingMatrix;
        fRec.computeMatrices(
                SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix);
 
        fDoLinearMetrics = this->isLinearMetrics();
        if (SkMask::kBW_Format == fRec.fMaskFormat) {
            if (fRec.getHinting() == SkFontHinting::kNone) {
                fHintingInstance = fontations_ffi::no_hinting_instance();
                fDoLinearMetrics = true;
            } else {
                fHintingInstance = fontations_ffi::make_mono_hinting_instance(
                        fOutlines, scale.fY, fBridgeNormalizedCoords);
                fDoLinearMetrics = false;
            }
        } else {
            switch (fRec.getHinting()) {
                case SkFontHinting::kNone:
                    fHintingInstance = fontations_ffi::no_hinting_instance();
                    fDoLinearMetrics = true;
                    break;
                case SkFontHinting::kSlight:
                    // Unhinted metrics.
                    fHintingInstance = fontations_ffi::make_hinting_instance(
                            fOutlines,
                            scale.fY,
                            fBridgeNormalizedCoords,
                            false /* do_lcd_antialiasing */,
                            false /* lcd_orientation_vertical */,
                            true /* preserve_linear_metrics */);
                    fDoLinearMetrics = true;
                    break;
                case SkFontHinting::kNormal:
                    // No hinting to subpixel coordinates.
                    fHintingInstance = fontations_ffi::make_hinting_instance(
                            fOutlines,
                            scale.fY,
                            fBridgeNormalizedCoords,
                            false /* do_lcd_antialiasing */,
                            false /* lcd_orientation_vertical */,
                            fDoLinearMetrics /* preserve_linear_metrics */);
                    break;
                case SkFontHinting::kFull:
                    // Attempt to make use of hinting to subpixel coordinates.
                    fHintingInstance = fontations_ffi::make_hinting_instance(
                            fOutlines,
                            scale.fY,
                            fBridgeNormalizedCoords,
                            isLCD(fRec) /* do_lcd_antialiasing */,
                            SkToBool(fRec.fFlags &
                                     SkScalerContext::
                                             kLCD_Vertical_Flag) /* lcd_orientation_vertical */,
                            fDoLinearMetrics /* preserve_linear_metrics */);
            }
        }
    }

Member Function Documentation

drawCOLRGlyph()

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

inlineprotected

Definition at line 744 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 767 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 798 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 684 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 466 of file SkTypeface_fontations.cpp.

                                                                               {
        GlyphMetrics mx(glyph.maskFormat());
 
        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());
 
        // Local overrides for color fonts etc. may alter the request for linear metrics.
        bool doLinearMetrics = fDoLinearMetrics;
 
        if (has_bitmap_glyph) {
            // Bitmap advance metrics can originate from different strike sizes in the bitmap
            // font and are thus not linearly scaling with font size.
            doLinearMetrics = false;
        }
        if (has_colrv0_glyph || has_colrv1_glyph) {
            // We prefer color vector glyphs, and hinting is disabled for those.
            doLinearMetrics = true;
        }
 
        SkVector scale;
        SkMatrix remainingMatrix;
        if (!fRec.computeMatrices(
                    SkScalerContextRec::PreMatrixScale::kVertical, &scale, &remainingMatrix)) {
            return mx;
        }
        float x_advance = 0.0f;
        x_advance = fontations_ffi::unhinted_advance_width_or_zero(
                fBridgeFontRef, scale.y(), fBridgeNormalizedCoords, glyph.getGlyphID());
        if (!doLinearMetrics) {
            float hinted_advance = 0;
            fontations_ffi::scaler_hinted_advance_width(
                    fOutlines, *fHintingInstance, glyph.getGlyphID(), hinted_advance);
            // TODO(drott): Remove this workaround for fontations returning 0
            // for a space glyph without contours, compare
            // https://github.com/googlefonts/fontations/issues/905
            if (hinted_advance != x_advance && hinted_advance != 0) {
                x_advance = hinted_advance;
            }
        }
        mx.advance = remainingMatrix.mapXY(x_advance, SkFloatToScalar(0.f));
 
        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);
 
            // 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);
            matrix.preTranslate( bitmapMetrics.inner_bearing_x,
                                -bitmapMetrics.inner_bearing_y);
 
            // 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());
 
            if (SkIsFinite(bitmapMetrics.advance)) {
                mx.advance = matrix.mapVector(bitmapMetrics.advance, 0);
            }
        } else {
            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 725 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(), *fHintingInstance);
        if (!result) {
            return false;
        }
 
        *path = path->makeTransform(remainingMatrix);
        return true;
    }

generatePngImage()

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

inlineprotected

Definition at line 617 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, const fontations_ffi::BridgeHintingInstance &  hintingInstance  )

inline

Definition at line 430 of file SkTypeface_fontations.cpp.

                                                                        {
        sk_fontations::PathGeometrySink pathWrapper;
        fontations_ffi::BridgeScalerMetrics scalerMetrics;
 
        if (!fontations_ffi::get_path(fOutlines,
                                      glyphId,
                                      yScale,
                                      fBridgeNormalizedCoords,
                                      hintingInstance,
                                      pathWrapper,
                                      scalerMetrics)) {
            return false;
        }
        *path = std::move(pathWrapper).into_inner();
 
        // See https://issues.skia.org/345178242 for details:
        // The FreeType backend performs a path simplification here based on the
        // equivalent of what we have here as scalerMetrics.has_overlaps
        // Since PathOps::Simplify fails or at times produces incorrect simplified
        // contours, skip that step here.
        return true;
    }

Friends And Related Function Documentation

sk_fontations::ColorPainter

friend class sk_fontations::ColorPainter

friend

Definition at line 854 of file SkTypeface_fontations.cpp.

---

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

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