sktext::gpu Namespace Reference

Classes
struct	AtlasPt
class	AtlasSubRun
class	BagOfBytes
class	DistanceFieldAdjustTable
class	Glyph
class	GlyphVector
class	GlyphVectorTestingPeer
struct	RendererData
class	SDFMaskFilter
class	SDFMaskFilterImpl
class	SDFTControl
class	SDFTMatrixRange
class	Slug
class	SlugImpl
class	StrikeCache
class	STSubRunAllocator
class	SubRun
class	SubRunAllocator
class	SubRunContainer
class	SubRunInitializer
class	SubRunList
class	TextBlob
class	TextBlobRedrawCoordinator
class	TextBlobTools
class	TextStrike
class	VertexFiller

Typedefs
using	Rect = skgpu::graphite::Rect
using	Transform = skgpu::graphite::Transform
using	DrawAtlas = skgpu::graphite::DrawAtlas
using	RegenerateAtlasDelegate = std::function< std::tuple< bool, int >(GlyphVector *, int begin, int end, skgpu::MaskFormat, int padding)>
using	AtlasDrawDelegate = std::function< void(const sktext::gpu::AtlasSubRun *subRun, SkPoint drawOrigin, const SkPaint &paint, sk_sp< SkRefCnt > subRunStorage, sktext::gpu::RendererData)>
using	SubRunOwner = std::unique_ptr< SubRun, SubRunAllocator::Destroyer >
using	SubRunContainerOwner = std::unique_ptr< SubRunContainer, SubRunAllocator::Destroyer >

Enumerations
enum	FillerType { kIsDirect , kIsTransformed }

Functions
	SkDEBUGCODE (static const int kExpectedDistanceAdjustTableSize=8;) SkScalar *build_distance_adjust_table(SkScalar deviceGamma)
SkMatrix	position_matrix (const SkMatrix &drawMatrix, SkPoint drawOrigin)
SkScalar	find_maximum_glyph_dimension (StrikeForGPU *strike, SkSpan< const SkGlyphID > glyphs)
std::tuple< SkZip< const SkPackedGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint >, SkRect >	prepare_for_SDFT_drawing (StrikeForGPU *strike, const SkMatrix &creationMatrix, SkZip< const SkGlyphID, const SkPoint > source, SkZip< SkPackedGlyphID, SkPoint > acceptedBuffer, SkZip< SkGlyphID, SkPoint > rejectedBuffer)
std::tuple< SkZip< const SkPackedGlyphID, const SkPoint, const SkMask::Format >, SkZip< SkGlyphID, SkPoint >, SkRect >	prepare_for_direct_mask_drawing (StrikeForGPU *strike, const SkMatrix &positionMatrix, SkZip< const SkGlyphID, const SkPoint > source, SkZip< SkPackedGlyphID, SkPoint, SkMask::Format > acceptedBuffer, SkZip< SkGlyphID, SkPoint > rejectedBuffer)
std::tuple< SkZip< const SkPackedGlyphID, const SkPoint, const SkMask::Format >, SkZip< SkGlyphID, SkPoint >, SkRect >	prepare_for_mask_drawing (StrikeForGPU *strike, const SkMatrix &creationMatrix, SkZip< const SkGlyphID, const SkPoint > source, SkZip< SkPackedGlyphID, SkPoint, SkMask::Format > acceptedBuffer, SkZip< SkGlyphID, SkPoint > rejectedBuffer)
std::tuple< SkZip< const SkGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint > >	prepare_for_path_drawing (StrikeForGPU *strike, SkZip< const SkGlyphID, const SkPoint > source, SkZip< SkGlyphID, SkPoint > acceptedBuffer, SkZip< SkGlyphID, SkPoint > rejectedBuffer)
std::tuple< SkZip< const SkGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint > >	prepare_for_drawable_drawing (StrikeForGPU *strike, SkZip< const SkGlyphID, const SkPoint > source, SkZip< SkGlyphID, SkPoint > acceptedBuffer, SkZip< SkGlyphID, SkPoint > rejectedBuffer)
static std::tuple< SkStrikeSpec, SkScalar, sktext::gpu::SDFTMatrixRange >	make_sdft_strike_spec (const SkFont &font, const SkPaint &paint, const SkSurfaceProps &surfaceProps, const SkMatrix &deviceMatrix, const SkPoint &textLocation, const sktext::gpu::SDFTControl &control)
SkSpan< SkPoint >	MakePointsFromBuffer (SkReadBuffer &buffer, SubRunAllocator *alloc)
sk_sp< Slug >	MakeSlug (const SkMatrix &drawMatrix, const sktext::GlyphRunList &glyphRunList, const SkPaint &paint, SkStrikeDeviceInfo strikeDeviceInfo, sktext::StrikeForGPUCacheInterface *strikeCache)
static std::tuple< bool, SkVector >	can_use_direct (const SkMatrix &creationMatrix, const SkMatrix &positionMatrix)
	DEF_TEST (GlyphVector_Serialization, r)
	DEF_TEST (GlyphVector_BadLengths, r)

Variables
static const int	kSmallDFFontLimit = 32
static const int	kMediumDFFontLimit = 72
static const int	kLargeDFFontLimit = 162

Typedef Documentation

AtlasDrawDelegate

using sktext::gpu::AtlasDrawDelegate = typedef std::function<void(const sktext::gpu::AtlasSubRun* subRun, SkPoint drawOrigin, const SkPaint& paint, sk_sp<SkRefCnt> subRunStorage, sktext::gpu::RendererData)>

Definition at line 119 of file SubRunContainer.h.

DrawAtlas

using sktext::gpu::DrawAtlas = typedef skgpu::graphite::DrawAtlas

Definition at line 321 of file TextAtlasManager.cpp.

Rect

using sktext::gpu::Rect = typedef skgpu::graphite::Rect

Definition at line 51 of file GraphiteVertexFiller.cpp.

RegenerateAtlasDelegate

using sktext::gpu::RegenerateAtlasDelegate = typedef std::function<std::tuple<bool, int>(GlyphVector*, int begin, int end, skgpu::MaskFormat, int padding)>

Definition at line 57 of file SubRunContainer.h.

SubRunContainerOwner

using sktext::gpu::SubRunContainerOwner = typedef std::unique_ptr<SubRunContainer, SubRunAllocator::Destroyer>

Definition at line 204 of file SubRunContainer.h.

SubRunOwner

using sktext::gpu::SubRunOwner = typedef std::unique_ptr<SubRun, SubRunAllocator::Destroyer>

Definition at line 129 of file SubRunContainer.h.

Transform

using sktext::gpu::Transform = typedef skgpu::graphite::Transform

Definition at line 52 of file GraphiteVertexFiller.cpp.

Enumeration Type Documentation

FillerType

enum sktext::gpu::FillerType

Enumerator
kIsDirect
kIsTransformed

Definition at line 45 of file VertexFiller.h.

                {
    kIsDirect,
    kIsTransformed
};

Function Documentation

can_use_direct()

static std::tuple< bool, SkVector > sktext::gpu::can_use_direct ( const SkMatrix &  creationMatrix, const SkMatrix &  positionMatrix  )

static

Definition at line 98 of file VertexFiller.cpp.

                                                                        {
    // The existing direct glyph info can be used if the creationMatrix, and the
    // positionMatrix have the same 2x2, the translation between them is integer, and no
    // perspective is involved. Calculate the translation in source space to a translation in
    // device space by mapping (0, 0) through both the creationMatrix and the positionMatrix;
    // take the difference.
    SkVector translation = positionMatrix.mapOrigin() - creationMatrix.mapOrigin();
    return {creationMatrix.getScaleX() == positionMatrix.getScaleX() &&
            creationMatrix.getScaleY() == positionMatrix.getScaleY() &&
            creationMatrix.getSkewX()  == positionMatrix.getSkewX()  &&
            creationMatrix.getSkewY()  == positionMatrix.getSkewY()  &&
            !positionMatrix.hasPerspective() && !creationMatrix.hasPerspective() &&
            SkScalarIsInt(translation.x()) && SkScalarIsInt(translation.y()),
            translation};
}

DEF_TEST() [1/2]

sktext::gpu::DEF_TEST	(	GlyphVector_BadLengths	,
		r
	)

Definition at line 79 of file GrGlyphVectorTest.cpp.

                                    {
    auto [strikeSpec, _] = SkStrikeSpec::MakeCanonicalized(ToolUtils::DefaultFont());
 
    // Strike to keep in the strike cache.
    auto strike = strikeSpec.findOrCreateStrike();
 
    // Be sure to keep the strike alive. The promise to serialize as the first part of the
    // GlyphVector.
    SkStrikePromise promise{sk_sp<SkStrike>(strike)};
    {
        // Make broken stream by hand - zero length
        SkBinaryWriteBuffer wBuffer({});
        promise.flatten(wBuffer);
        wBuffer.write32(0);  // length
        auto data = wBuffer.snapshotAsData();
        SkReadBuffer rBuffer{data->data(), data->size()};
        SubRunAllocator alloc;
        auto dst = GlyphVector::MakeFromBuffer(rBuffer, nullptr, &alloc);
        REPORTER_ASSERT(r, !dst.has_value());
    }
 
    {
        // Make broken stream by hand - zero length
        SkBinaryWriteBuffer wBuffer({});
        promise.flatten(wBuffer);
        // Make broken stream by hand - stream is too short
        wBuffer.write32(5);  // length
        wBuffer.writeUInt(12);  // random data
        wBuffer.writeUInt(12);  // random data
        wBuffer.writeUInt(12);  // random data
        auto data = wBuffer.snapshotAsData();
        SkReadBuffer rBuffer{data->data(), data->size()};
        SubRunAllocator alloc;
        auto dst = GlyphVector::MakeFromBuffer(rBuffer, nullptr, &alloc);
        REPORTER_ASSERT(r, !dst.has_value());
    }
 
    {
        // Make broken stream by hand - length out of range of safe calculations
        SkBinaryWriteBuffer wBuffer({});
        promise.flatten(wBuffer);
        wBuffer.write32(INT_MAX - 10);  // length
        wBuffer.writeUInt(12);  // random data
        wBuffer.writeUInt(12);  // random data
        wBuffer.writeUInt(12);  // random data
        auto data = wBuffer.snapshotAsData();
        SkReadBuffer rBuffer{data->data(), data->size()};
        SubRunAllocator alloc;
        auto dst = GlyphVector::MakeFromBuffer(rBuffer, nullptr, &alloc);
        REPORTER_ASSERT(r, !dst.has_value());
    }
}

DEF_TEST() [2/2]

sktext::gpu::DEF_TEST	(	GlyphVector_Serialization	,
		r
	)

Definition at line 45 of file GrGlyphVectorTest.cpp.

                                       {
    SkFont font = ToolUtils::DefaultFont();
    auto [strikeSpec, _] = SkStrikeSpec::MakeCanonicalized(font);
 
    SubRunAllocator alloc;
 
    const int N = 10;
    SkPackedGlyphID* glyphs = alloc.makePODArray<SkPackedGlyphID>(N);
    for (int i = 0; i < N; i++) {
        glyphs[i] = SkPackedGlyphID(SkGlyphID(i));
    }
 
    SkStrikePromise promise{strikeSpec.findOrCreateStrike()};
 
    GlyphVector src = GlyphVector::Make(std::move(promise), SkSpan(glyphs, N), &alloc);
 
    SkBinaryWriteBuffer wBuffer({});
    src.flatten(wBuffer);
 
    auto data = wBuffer.snapshotAsData();
    SkReadBuffer rBuffer{data->data(), data->size()};
    auto dst = GlyphVector::MakeFromBuffer(rBuffer, nullptr, &alloc);
    REPORTER_ASSERT(r, dst.has_value());
    REPORTER_ASSERT(r,
                    GlyphVectorTestingPeer::GetDescriptor(src) ==
                            GlyphVectorTestingPeer::GetDescriptor(*dst));
 
    auto srcGlyphs = GlyphVectorTestingPeer::GetGlyphs(src);
    auto dstGlyphs = GlyphVectorTestingPeer::GetGlyphs(*dst);
    for (auto [srcGlyphID, dstGlyphID] : SkMakeZip(srcGlyphs, dstGlyphs)) {
        REPORTER_ASSERT(r, srcGlyphID.packedGlyphID == dstGlyphID.packedGlyphID);
    }
}

find_maximum_glyph_dimension()

SkScalar sktext::gpu::find_maximum_glyph_dimension	(	StrikeForGPU *	strike,
		SkSpan< const SkGlyphID >	glyphs
	)

Definition at line 1431 of file SubRunContainer.cpp.

                                                                                            {
    StrikeMutationMonitor m{strike};
    SkScalar maxDimension = 0;
    for (SkGlyphID glyphID : glyphs) {
        SkGlyphDigest digest = strike->digestFor(kMask, SkPackedGlyphID{glyphID});
        maxDimension = std::max(static_cast<SkScalar>(digest.maxDimension()), maxDimension);
    }
 
    return maxDimension;
}

make_sdft_strike_spec()

static std::tuple< SkStrikeSpec, SkScalar, sktext::gpu::SDFTMatrixRange > sktext::gpu::make_sdft_strike_spec ( const SkFont &  font, const SkPaint &  paint, const SkSurfaceProps &  surfaceProps, const SkMatrix &  deviceMatrix, const SkPoint &  textLocation, const sktext::gpu::SDFTControl &  control  )

static

Definition at line 1637 of file SubRunContainer.cpp.

                                                                                        {
    // Add filter to the paint which creates the SDFT data for A8 masks.
    SkPaint dfPaint{paint};
    dfPaint.setMaskFilter(sktext::gpu::SDFMaskFilter::Make());
 
    auto [dfFont, strikeToSourceScale, matrixRange] = control.getSDFFont(font, deviceMatrix,
                                                                         textLocation);
 
    // Adjust the stroke width by the scale factor for drawing the SDFT.
    dfPaint.setStrokeWidth(paint.getStrokeWidth() / strikeToSourceScale);
 
    // Check for dashing and adjust the intervals.
    if (SkPathEffect* pathEffect = paint.getPathEffect(); pathEffect != nullptr) {
        SkPathEffect::DashInfo dashInfo;
        if (pathEffect->asADash(&dashInfo) == SkPathEffect::kDash_DashType) {
            if (dashInfo.fCount > 0) {
                // Allocate the intervals.
                std::vector<SkScalar> scaledIntervals(dashInfo.fCount);
                dashInfo.fIntervals = scaledIntervals.data();
                // Call again to get the interval data.
                (void)pathEffect->asADash(&dashInfo);
                for (SkScalar& interval : scaledIntervals) {
                    interval /= strikeToSourceScale;
                }
                auto scaledDashes = SkDashPathEffect::Make(scaledIntervals.data(),
                                                           scaledIntervals.size(),
                                                           dashInfo.fPhase / strikeToSourceScale);
                dfPaint.setPathEffect(scaledDashes);
            }
        }
    }
 
    // Fake-gamma and subpixel antialiasing are applied in the shader, so we ignore the
    // passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
    SkScalerContextFlags flags = SkScalerContextFlags::kNone;
    SkStrikeSpec strikeSpec = SkStrikeSpec::MakeMask(dfFont, dfPaint, surfaceProps, flags,
                                                     SkMatrix::I());
 
    return std::make_tuple(std::move(strikeSpec), strikeToSourceScale, matrixRange);
}

MakePointsFromBuffer()

SkSpan< SkPoint > sktext::gpu::MakePointsFromBuffer	(	SkReadBuffer &	buffer,
		SubRunAllocator *	alloc
	)

Definition at line 1996 of file SubRunContainer.cpp.

                                                                                   {
    uint32_t glyphCount = buffer.getArrayCount();
 
    // Zero indicates a problem with serialization.
    if (!buffer.validate(glyphCount != 0)) { return {}; }
 
    // Check that the count will not overflow the arena.
    if (!buffer.validate(glyphCount <= INT_MAX &&
                         BagOfBytes::WillCountFit<SkPoint>(glyphCount))) { return {}; }
 
    SkPoint* positionsData = alloc->makePODArray<SkPoint>(glyphCount);
    if (!buffer.readPointArray(positionsData, glyphCount)) { return {}; }
    return {positionsData, glyphCount};
}

MakeSlug()

sk_sp< sktext::gpu::Slug > sktext::gpu::MakeSlug	(	const SkMatrix &	drawMatrix,
		const sktext::GlyphRunList &	glyphRunList,
		const SkPaint &	paint,
		SkStrikeDeviceInfo	strikeDeviceInfo,
		sktext::StrikeForGPUCacheInterface *	strikeCache
	)

Definition at line 255 of file TextBlob.cpp.

                                                                    {
    return SlugImpl::Make(drawMatrix, glyphRunList, paint, strikeDeviceInfo, strikeCache);
}

position_matrix()

SkMatrix sktext::gpu::position_matrix	(	const SkMatrix &	drawMatrix,
		SkPoint	drawOrigin
	)

Definition at line 69 of file SlugImpl.cpp.

                                                                         {
    SkMatrix position_matrix = drawMatrix;
    return position_matrix.preTranslate(drawOrigin.x(), drawOrigin.y());
}

prepare_for_direct_mask_drawing()

std::tuple< SkZip< const SkPackedGlyphID, const SkPoint, const SkMask::Format >, SkZip< SkGlyphID, SkPoint >, SkRect > sktext::gpu::prepare_for_direct_mask_drawing	(	StrikeForGPU *	strike,
		const SkMatrix &	positionMatrix,
		SkZip< const SkGlyphID, const SkPoint >	source,
		SkZip< SkPackedGlyphID, SkPoint, SkMask::Format >	acceptedBuffer,
		SkZip< SkGlyphID, SkPoint >	rejectedBuffer
	)

Definition at line 1490 of file SubRunContainer.cpp.

                                                                          {
    const SkIPoint mask = strike->roundingSpec().ignorePositionFieldMask;
    const SkPoint halfSampleFreq = strike->roundingSpec().halfAxisSampleFreq;
 
    // Build up the mapping from source space to device space. Add the rounding constant
    // halfSampleFreq, so we just need to floor to get the device result.
    SkMatrix positionMatrixWithRounding = positionMatrix;
    positionMatrixWithRounding.postTranslate(halfSampleFreq.x(), halfSampleFreq.y());
 
    int acceptedSize = 0,
        rejectedSize = 0;
    SkGlyphRect boundingRect = skglyph::empty_rect();
    StrikeMutationMonitor m{strike};
    for (auto [glyphID, pos] : source) {
        if (!SkIsFinite(pos.x(), pos.y())) {
            continue;
        }
 
        const SkPoint mappedPos = positionMatrixWithRounding.mapPoint(pos);
        const SkPackedGlyphID packedID{glyphID, mappedPos, mask};
        switch (const SkGlyphDigest digest = strike->digestFor(skglyph::kDirectMask, packedID);
                digest.actionFor(skglyph::kDirectMask)) {
            case GlyphAction::kAccept: {
                const SkPoint roundedPos{SkScalarFloorToScalar(mappedPos.x()),
                                         SkScalarFloorToScalar(mappedPos.y())};
                const SkGlyphRect glyphBounds = digest.bounds().offset(roundedPos);
                boundingRect = skglyph::rect_union(boundingRect, glyphBounds);
                acceptedBuffer[acceptedSize++] =
                        std::make_tuple(packedID, glyphBounds.leftTop(), digest.maskFormat());
                break;
            }
            case GlyphAction::kReject:
                rejectedBuffer[rejectedSize++] = std::make_tuple(glyphID, pos);
                break;
            default:
                break;
        }
    }
 
    return {acceptedBuffer.first(acceptedSize),
            rejectedBuffer.first(rejectedSize),
            boundingRect.rect()};
}

prepare_for_drawable_drawing()

std::tuple< SkZip< const SkGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint > > sktext::gpu::prepare_for_drawable_drawing	(	StrikeForGPU *	strike,
		SkZip< const SkGlyphID, const SkPoint >	source,
		SkZip< SkGlyphID, SkPoint >	acceptedBuffer,
		SkZip< SkGlyphID, SkPoint >	rejectedBuffer
	)

Definition at line 1608 of file SubRunContainer.cpp.

                                                                       {
    int acceptedSize = 0;
    int rejectedSize = 0;
    StrikeMutationMonitor m{strike};
    for (const auto [glyphID, pos] : source) {
        if (!SkIsFinite(pos.x(), pos.y())) {
            continue;
        }
 
        switch (strike->digestFor(skglyph::kDrawable, SkPackedGlyphID{glyphID})
                       .actionFor(skglyph::kDrawable)) {
            case GlyphAction::kAccept:
                acceptedBuffer[acceptedSize++] = std::make_tuple(glyphID, pos);
                break;
            case GlyphAction::kReject:
                rejectedBuffer[rejectedSize++] = std::make_tuple(glyphID, pos);
                break;
            default:
                break;
        }
    }
    return {acceptedBuffer.first(acceptedSize), rejectedBuffer.first(rejectedSize)};
}

prepare_for_mask_drawing()

std::tuple< SkZip< const SkPackedGlyphID, const SkPoint, const SkMask::Format >, SkZip< SkGlyphID, SkPoint >, SkRect > sktext::gpu::prepare_for_mask_drawing	(	StrikeForGPU *	strike,
		const SkMatrix &	creationMatrix,
		SkZip< const SkGlyphID, const SkPoint >	source,
		SkZip< SkPackedGlyphID, SkPoint, SkMask::Format >	acceptedBuffer,
		SkZip< SkGlyphID, SkPoint >	rejectedBuffer
	)

Definition at line 1541 of file SubRunContainer.cpp.

                                                                   {
    int acceptedSize = 0,
        rejectedSize = 0;
    SkGlyphRect boundingRect = skglyph::empty_rect();
    StrikeMutationMonitor m{strike};
    for (auto [glyphID, pos] : source) {
        if (!SkIsFinite(pos.x(), pos.y())) {
            continue;
        }
 
        const SkPackedGlyphID packedID{glyphID};
        switch (const SkGlyphDigest digest = strike->digestFor(kMask, packedID);
                digest.actionFor(kMask)) {
            case GlyphAction::kAccept: {
                const SkPoint mappedPos = creationMatrix.mapPoint(pos);
                const SkGlyphRect glyphBounds = digest.bounds().offset(mappedPos);
                boundingRect = skglyph::rect_union(boundingRect, glyphBounds);
                acceptedBuffer[acceptedSize++] =
                        std::make_tuple(packedID, glyphBounds.leftTop(), digest.maskFormat());
                break;
            }
            case GlyphAction::kReject:
                rejectedBuffer[rejectedSize++] = std::make_tuple(glyphID, pos);
                break;
            default:
                break;
        }
    }
 
    return {acceptedBuffer.first(acceptedSize),
            rejectedBuffer.first(rejectedSize),
            boundingRect.rect()};
}

prepare_for_path_drawing()

std::tuple< SkZip< const SkGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint > > sktext::gpu::prepare_for_path_drawing	(	StrikeForGPU *	strike,
		SkZip< const SkGlyphID, const SkPoint >	source,
		SkZip< SkGlyphID, SkPoint >	acceptedBuffer,
		SkZip< SkGlyphID, SkPoint >	rejectedBuffer
	)

Definition at line 1580 of file SubRunContainer.cpp.

                                                                   {
    int acceptedSize = 0;
    int rejectedSize = 0;
    StrikeMutationMonitor m{strike};
    for (const auto [glyphID, pos] : source) {
        if (!SkIsFinite(pos.x(), pos.y())) {
            continue;
        }
 
        switch (strike->digestFor(skglyph::kPath, SkPackedGlyphID{glyphID})
                       .actionFor(skglyph::kPath)) {
            case GlyphAction::kAccept:
                acceptedBuffer[acceptedSize++] = std::make_tuple(glyphID, pos);
                break;
            case GlyphAction::kReject:
                rejectedBuffer[rejectedSize++] = std::make_tuple(glyphID, pos);
                break;
            default:
                break;
        }
    }
    return {acceptedBuffer.first(acceptedSize), rejectedBuffer.first(rejectedSize)};
}

prepare_for_SDFT_drawing()

std::tuple< SkZip< const SkPackedGlyphID, const SkPoint >, SkZip< SkGlyphID, SkPoint >, SkRect > sktext::gpu::prepare_for_SDFT_drawing	(	StrikeForGPU *	strike,
		const SkMatrix &	creationMatrix,
		SkZip< const SkGlyphID, const SkPoint >	source,
		SkZip< SkPackedGlyphID, SkPoint >	acceptedBuffer,
		SkZip< SkGlyphID, SkPoint >	rejectedBuffer
	)

Definition at line 1444 of file SubRunContainer.cpp.

                                                                   {
    int acceptedSize = 0,
        rejectedSize = 0;
    SkGlyphRect boundingRect = skglyph::empty_rect();
    StrikeMutationMonitor m{strike};
    for (const auto [glyphID, pos] : source) {
        if (!SkIsFinite(pos.x(), pos.y())) {
            continue;
        }
 
        const SkPackedGlyphID packedID{glyphID};
        switch (const SkGlyphDigest digest = strike->digestFor(skglyph::kSDFT, packedID);
                digest.actionFor(skglyph::kSDFT)) {
            case GlyphAction::kAccept: {
                SkPoint mappedPos = creationMatrix.mapPoint(pos);
                const SkGlyphRect glyphBounds =
                    digest.bounds()
                        // The SDFT glyphs have 2-pixel wide padding that should
                        // not be used in calculating the source rectangle.
                        .inset(SK_DistanceFieldInset, SK_DistanceFieldInset)
                        .offset(mappedPos);
                boundingRect = skglyph::rect_union(boundingRect, glyphBounds);
                acceptedBuffer[acceptedSize++] = std::make_tuple(packedID, glyphBounds.leftTop());
                break;
            }
            case GlyphAction::kReject:
                rejectedBuffer[rejectedSize++] = std::make_tuple(glyphID, pos);
            break;
            default:
                break;
        }
    }
 
    return {acceptedBuffer.first(acceptedSize),
            rejectedBuffer.first(rejectedSize),
            boundingRect.rect()};
}

SkDEBUGCODE()

sktext::gpu::SkDEBUGCODE

(

static const int

kExpectedDistanceAdjustTableSize = 8;

)

Definition at line 23 of file DistanceFieldAdjustTable.cpp.

                                                            {
    // This is used for an approximation of the mask gamma hack, used by raster and bitmap
    // text. The mask gamma hack is based off of guessing what the blend color is going to
    // be, and adjusting the mask so that when run through the linear blend will
    // produce the value closest to the desired result. However, in practice this means
    // that the 'adjusted' mask is just increasing or decreasing the coverage of
    // the mask depending on what it is thought it will blit against. For black (on
    // assumed white) this means that coverages are decreased (on a curve). For white (on
    // assumed black) this means that coverages are increased (on a a curve). At
    // middle (perceptual) gray (which could be blit against anything) the coverages
    // remain the same.
    //
    // The idea here is that instead of determining the initial (real) coverage and
    // then adjusting that coverage, we determine an adjusted coverage directly by
    // essentially manipulating the geometry (in this case, the distance to the glyph
    // edge). So for black (on assumed white) this thins a bit; for white (on
    // assumed black) this fake bolds the geometry a bit.
    //
    // The distance adjustment is calculated by determining the actual coverage value which
    // when fed into in the mask gamma table gives us an 'adjusted coverage' value of 0.5. This
    // actual coverage value (assuming it's between 0 and 1) corresponds to a distance from the
    // actual edge. So by subtracting this distance adjustment and computing without the
    // the coverage adjustment we should get 0.5 coverage at the same point.
    //
    // This has several implications:
    //     For non-gray lcd smoothed text, each subpixel essentially is using a
    //     slightly different geometry.
    //
    //     For black (on assumed white) this may not cover some pixels which were
    //     previously covered; however those pixels would have been only slightly
    //     covered and that slight coverage would have been decreased anyway. Also, some pixels
    //     which were previously fully covered may no longer be fully covered.
    //
    //     For white (on assumed black) this may cover some pixels which weren't
    //     previously covered at all.
 
    int width, height;
    size_t size;
    SkScalar contrast = SK_GAMMA_CONTRAST;
 
    size = SkScalerContext::GetGammaLUTSize(contrast, deviceGamma,
        &width, &height);
 
    SkASSERT(kExpectedDistanceAdjustTableSize == height);
    SkScalar* table = new SkScalar[height];
 
    AutoTArray<uint8_t> data((int)size);
    if (!SkScalerContext::GetGammaLUTData(contrast, deviceGamma, data.get())) {
        // if no valid data is available simply do no adjustment
        for (int row = 0; row < height; ++row) {
            table[row] = 0;
        }
        return table;
    }
 
    // find the inverse points where we cross 0.5
    // binsearch might be better, but we only need to do this once on creation
    for (int row = 0; row < height; ++row) {
        uint8_t* rowPtr = data.get() + row*width;
        for (int col = 0; col < width - 1; ++col) {
            if (rowPtr[col] <= 127 && rowPtr[col + 1] >= 128) {
                // compute point where a mask value will give us a result of 0.5
                float interp = (127.5f - rowPtr[col]) / (rowPtr[col + 1] - rowPtr[col]);
                float borderAlpha = (col + interp) / 255.f;
 
                // compute t value for that alpha
                // this is an approximate inverse for smoothstep()
                float t = borderAlpha*(borderAlpha*(4.0f*borderAlpha - 6.0f) + 5.0f) / 3.0f;
 
                // compute distance which gives us that t value
                const float kDistanceFieldAAFactor = 0.65f; // should match SK_DistanceFieldAAFactor
                float d = 2.0f*kDistanceFieldAAFactor*t - kDistanceFieldAAFactor;
 
                table[row] = d;
                break;
            }
        }
    }
 
    return table;
}

Variable Documentation

kLargeDFFontLimit

const int sktext::gpu::kLargeDFFontLimit = 162

static

Definition at line 32 of file SDFTControl.cpp.

kMediumDFFontLimit

const int sktext::gpu::kMediumDFFontLimit = 72

static

Definition at line 31 of file SDFTControl.cpp.

kSmallDFFontLimit

const int sktext::gpu::kSmallDFFontLimit = 32

static

Definition at line 30 of file SDFTControl.cpp.