sktext::gpu::VertexFiller Class Reference

#include <VertexFiller.h>

Public Member Functions
	VertexFiller (skgpu::MaskFormat maskFormat, const SkMatrix &creationMatrix, SkRect creationBounds, SkSpan< const SkPoint > leftTop, bool canDrawDirect)
int	unflattenSize () const
void	flatten (SkWriteBuffer &buffer) const
void	fillInstanceData (skgpu::graphite::DrawWriter *dw, int offset, int count, unsigned short flags, skvx::ushort2 ssboIndex, SkSpan< const Glyph * > glyphs, SkScalar depth) const
std::tuple< skgpu::graphite::Rect, skgpu::graphite::Transform >	boundsAndDeviceMatrix (const skgpu::graphite::Transform &localToDevice, SkPoint drawOrigin) const
std::tuple< bool, SkRect >	deviceRectAndCheckTransform (const SkMatrix &positionMatrix) const
skgpu::MaskFormat	grMaskType () const
bool	isLCD () const
int	count () const

Static Public Member Functions
static VertexFiller	Make (skgpu::MaskFormat maskType, const SkMatrix &creationMatrix, SkRect creationBounds, SkSpan< const SkPoint > positions, SubRunAllocator *alloc, FillerType fillerType)
static std::optional< VertexFiller >	MakeFromBuffer (SkReadBuffer &buffer, SubRunAllocator *alloc)

Detailed Description

Definition at line 60 of file VertexFiller.h.

Constructor & Destructor Documentation

VertexFiller()

sktext::gpu::VertexFiller::VertexFiller	(	skgpu::MaskFormat	maskFormat,
		const SkMatrix &	creationMatrix,
		SkRect	creationBounds,
		SkSpan< const SkPoint >	leftTop,
		bool	canDrawDirect
	)

Definition at line 37 of file VertexFiller.cpp.

            : fMaskType{maskFormat}, fCanDrawDirect{canDrawDirect},
              fCreationMatrix{creationMatrix}, fCreationBounds{creationBounds},
              fLeftTop{leftTop} {}

Member Function Documentation

boundsAndDeviceMatrix()

std::tuple< Rect, Transform > sktext::gpu::VertexFiller::boundsAndDeviceMatrix	(	const skgpu::graphite::Transform &	localToDevice,
		SkPoint	drawOrigin
	)		const

Definition at line 54 of file GraphiteVertexFiller.cpp.

                                                                                          {
    // The baked-in matrix differs from the current localToDevice by a translation if the
    // upper 2x2 remains the same, and there's no perspective. Since there's no projection,
    // Z is irrelevant, so it's okay that fCreationMatrix is an SkMatrix and has
    // discarded the 3rd row/col, and can ignore those values in localToDevice.
    const SkM44& positionMatrix = localToDevice.matrix();
    const bool compatibleMatrix = positionMatrix.rc(0,0) == fCreationMatrix.rc(0, 0) &&
                                  positionMatrix.rc(0,1) == fCreationMatrix.rc(0, 1) &&
                                  positionMatrix.rc(1,0) == fCreationMatrix.rc(1, 0) &&
                                  positionMatrix.rc(1,1) == fCreationMatrix.rc(1, 1) &&
                                  localToDevice.type() != Transform::Type::kPerspective &&
                                  !fCreationMatrix.hasPerspective();
 
    if (compatibleMatrix) {
        const SkV4 mappedOrigin = positionMatrix.map(drawOrigin.x(), drawOrigin.y(), 0.f, 1.f);
        const SkV2 offset = {mappedOrigin.x - fCreationMatrix.getTranslateX(),
                             mappedOrigin.y - fCreationMatrix.getTranslateY()};
        if (SkScalarIsInt(offset.x) && SkScalarIsInt(offset.y)) {
            // The offset is an integer (but make sure), which means the generated mask can be
            // accessed without changing how texels would be sampled.
            return {Rect(fCreationBounds),
                    Transform(SkM44::Translate(SkScalarRoundToInt(offset.x),
                                               SkScalarRoundToInt(offset.y)))};
        }
    }
 
    // Otherwise compute the relative transformation from fCreationMatrix to
    // localToDevice, with the drawOrigin applied. If fCreationMatrix or the
    // concatenation is not invertible the returned Transform is marked invalid and the draw
    // will be automatically dropped.
    const SkMatrix viewDifference = this->viewDifference(
            localToDevice.preTranslate(drawOrigin.x(), drawOrigin.y()));
    return {Rect(fCreationBounds), Transform(SkM44(viewDifference))};
}

count()

int sktext::gpu::VertexFiller::count ( ) const

inline

Definition at line 114 of file VertexFiller.h.

{ return SkCount(fLeftTop); }

deviceRectAndCheckTransform()

std::tuple< bool, SkRect > sktext::gpu::VertexFiller::deviceRectAndCheckTransform

(

const SkMatrix &

positionMatrix

)

const

Definition at line 355 of file VertexFiller.cpp.

                                                  {
    if (fCanDrawDirect) {
        const auto [directDrawCompatible, offset] =
                can_use_direct(fCreationMatrix, positionMatrix);
 
        if (directDrawCompatible) {
            return {true, fCreationBounds.makeOffset(offset)};
        }
    }
 
    if (SkMatrix inverse; fCreationMatrix.invert(&inverse)) {
        SkMatrix viewDifference = SkMatrix::Concat(positionMatrix, inverse);
        return {false, viewDifference.mapRect(fCreationBounds)};
    }
 
    // initialPositionMatrix is singular. Do nothing.
    return {false, SkRect::MakeEmpty()};
}

fillInstanceData()

void sktext::gpu::VertexFiller::fillInstanceData	(	skgpu::graphite::DrawWriter *	dw,
		int	offset,
		int	count,
		unsigned short	flags,
		skvx::ushort2	ssboIndex,
		SkSpan< const Glyph * >	glyphs,
		SkScalar	depth
	)		const

Definition at line 25 of file GraphiteVertexFiller.cpp.

                                                          {
    auto quadData = [&]() {
        return SkMakeZip(glyphs.subspan(offset, count),
                         fLeftTop.subspan(offset, count));
    };
 
    skgpu::graphite::DrawWriter::Instances instances{*dw, {}, {}, 4};
    instances.reserve(count);
    // Need to send width, height, uvPos, xyPos, and strikeToSourceScale
    // pre-transform coords = (s*w*b_x + t_x, s*h*b_y + t_y)
    // where (b_x, b_y) are the vertexID coords
    for (auto [glyph, leftTop]: quadData()) {
        auto[al, at, ar, ab] = glyph->fAtlasLocator.getUVs();
        instances.append(1) << AtlasPt{uint16_t(ar-al), uint16_t(ab-at)}
                            << AtlasPt{uint16_t(al & 0x1fff), at}
                            << leftTop << /*index=*/uint16_t(al >> 13) << flags
                            << 1.0f
                            << depth << ssboIndex;
    }
}

flatten()

void sktext::gpu::VertexFiller::flatten

(

SkWriteBuffer &

buffer

)

const

Definition at line 80 of file VertexFiller.cpp.

                                                      {
    buffer.writeInt(static_cast<int>(fMaskType));
    buffer.writeBool(fCanDrawDirect);
    buffer.writeMatrix(fCreationMatrix);
    buffer.writeRect(fCreationBounds);
    buffer.writePointArray(fLeftTop.data(), SkCount(fLeftTop));
}

grMaskType()

skgpu::MaskFormat sktext::gpu::VertexFiller::grMaskType ( ) const

inline

Definition at line 111 of file VertexFiller.h.

{ return fMaskType; }

isLCD()

bool sktext::gpu::VertexFiller::isLCD

(

)

const

Definition at line 350 of file VertexFiller.cpp.

{ return fMaskType == MaskFormat::kA565; }

Make()

VertexFiller sktext::gpu::VertexFiller::Make ( skgpu::MaskFormat  maskType, const SkMatrix &  creationMatrix, SkRect  creationBounds, SkSpan< const SkPoint >  positions, SubRunAllocator *  alloc, FillerType  fillerType  )

static

Definition at line 46 of file VertexFiller.cpp.

                                                       {
    SkSpan<SkPoint> leftTop = alloc->makePODSpan<SkPoint>(positions);
    return VertexFiller{
            maskType, creationMatrix, creationBounds, leftTop, fillerType == kIsDirect};
}

MakeFromBuffer()

std::optional< VertexFiller > sktext::gpu::VertexFiller::MakeFromBuffer ( SkReadBuffer &  buffer, SubRunAllocator *  alloc  )

static

Definition at line 57 of file VertexFiller.cpp.

                                                                                 {
    int checkingMaskType = buffer.readInt();
    if (!buffer.validate(
            0 <= checkingMaskType && checkingMaskType < skgpu::kMaskFormatCount)) {
        return std::nullopt;
    }
    MaskFormat maskType = (MaskFormat) checkingMaskType;
 
    const bool canDrawDirect = buffer.readBool();
 
    SkMatrix creationMatrix;
    buffer.readMatrix(&creationMatrix);
 
    SkRect creationBounds = buffer.readRect();
 
    SkSpan<SkPoint> leftTop = MakePointsFromBuffer(buffer, alloc);
    if (leftTop.empty()) { return std::nullopt; }
 
    SkASSERT(buffer.isValid());
    return VertexFiller{maskType, creationMatrix, creationBounds, leftTop, canDrawDirect};
}

unflattenSize()

int sktext::gpu::VertexFiller::unflattenSize ( ) const

inline

Definition at line 78 of file VertexFiller.h.

{ return fLeftTop.size_bytes(); }

---

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

• third_party/skia/src/text/gpu/VertexFiller.h
• third_party/skia/src/gpu/graphite/render/GraphiteVertexFiller.cpp
• third_party/skia/src/text/gpu/VertexFiller.cpp