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 paintGamma
	SkASSERT (kExpectedDistanceAdjustTableSize==height)
AutoTArray< uint8_t >	data ((int) size)
	if (!SkScalerContext::GetGammaLUTData(contrast, paintGamma, deviceGamma, data.get()))
	for (int row=0;row< height;++row)
SkMatrix	position_matrix (const SkMatrix &drawMatrix, SkPoint drawOrigin)
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
SkScalar	deviceGamma
size_t	size
SkScalar	contrast = SK_GAMMA_CONTRAST
SkScalar *	table = new SkScalar[height]
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 310 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};
}

data()

AutoTArray< uint8_t > sktext::gpu::data

(

(int)

size

)

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);
    }
}

for()

sktext::gpu::for

(

)

Definition at line 82 of file DistanceFieldAdjustTable.cpp.

                                           {
        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;
            }
        }
    }

if()

sktext::gpu::if

(

!

SkScalerContext::GetGammaLUTDatacontrast, paintGamma, deviceGamma, data.get()

)

Definition at line 72 of file DistanceFieldAdjustTable.cpp.

                                                                                        {
        // if no valid data is available simply do no adjustment
        for (int row = 0; row < height; ++row) {
            table[row] = 0;
        }
        return table;
    }

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());
}

SkASSERT()

sktext::gpu::SkASSERT

(

kExpectedDistanceAdjustTableSize

= =height

)

SkDEBUGCODE()

sktext::gpu::SkDEBUGCODE

(

static const int

kExpectedDistanceAdjustTableSize = 8;

)

Variable Documentation

contrast

SkScalar sktext::gpu::contrast = SK_GAMMA_CONTRAST

Definition at line 63 of file DistanceFieldAdjustTable.cpp.

deviceGamma

SkScalar sktext::gpu::deviceGamma

Definition at line 25 of file DistanceFieldAdjustTable.cpp.

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.

size

sktext::gpu::size

Initial value:

= SkScalerContext::GetGammaLUTSize(contrast, paintGamma, deviceGamma,
        &width, &height)

Definition at line 62 of file DistanceFieldAdjustTable.cpp.

table

return sktext::gpu::table = new SkScalar[height]

Definition at line 69 of file DistanceFieldAdjustTable.cpp.