SkVerticesPriv Class Reference

#include <SkVerticesPriv.h>

Public Member Functions
SkVertices::VertexMode	mode () const
bool	hasColors () const
bool	hasTexCoords () const
bool	hasIndices () const
int	vertexCount () const
int	indexCount () const
const SkPoint *	positions () const
const SkPoint *	texCoords () const
const SkColor *	colors () const
const uint16_t *	indices () const
	SkVerticesPriv (const SkVerticesPriv &)=default
void	encode (SkWriteBuffer &) const

Static Public Member Functions
static sk_sp< SkVertices >	Decode (SkReadBuffer &)

Friends
class	SkVertices

Detailed Description

Class that adds methods to SkVertices that are only intended for use internal to Skia. This class is purely a privileged window into SkVertices. It should never have additional data members or virtual methods.

Definition at line 23 of file SkVerticesPriv.h.

Constructor & Destructor Documentation

SkVerticesPriv()

SkVerticesPriv::SkVerticesPriv ( const SkVerticesPriv &  )

default

Member Function Documentation

colors()

const SkColor * SkVerticesPriv::colors ( ) const

inline

Definition at line 36 of file SkVerticesPriv.h.

{ return fVertices->fColors; }

Decode()

sk_sp< SkVertices > SkVerticesPriv::Decode ( SkReadBuffer &  buffer )

static

Definition at line 267 of file SkVertices.cpp.

                                                             {
    auto decode = [](SkReadBuffer& buffer) -> sk_sp<SkVertices> {
        SkSafeRange safe;
        bool hasCustomData = buffer.isVersionLT(SkPicturePriv::kVerticesRemoveCustomData_Version);
 
        const uint32_t packed = buffer.readUInt();
        const int vertexCount = safe.checkGE(buffer.readInt(), 0);
        const int indexCount = safe.checkGE(buffer.readInt(), 0);
        const int attrCount = hasCustomData ? safe.checkGE(buffer.readInt(), 0) : 0;
        const SkVertices::VertexMode mode = safe.checkLE<SkVertices::VertexMode>(
                packed & kMode_Mask, SkVertices::kLast_VertexMode);
        const bool hasTexs = SkToBool(packed & kHasTexs_Mask);
        const bool hasColors = SkToBool(packed & kHasColors_Mask);
 
        // Check that the header fields and buffer are valid. If this is data with the experimental
        // custom attributes feature - we don't support that any more.
        // We also don't support serialized triangle-fan data. We stopped writing that long ago,
        // so it should never appear in valid encoded data.
        if (!safe || !buffer.isValid() || attrCount ||
            mode == SkVertices::kTriangleFan_VertexMode) {
            return nullptr;
        }
 
        const SkVertices::Desc desc{mode, vertexCount, indexCount, hasTexs, hasColors};
        SkVertices::Sizes sizes(desc);
        if (!sizes.isValid() || sizes.fArrays > buffer.available()) {
            return nullptr;
        }
 
        SkVertices::Builder builder(desc);
        if (!builder.isValid()) {
            return nullptr;
        }
 
        buffer.readByteArray(builder.positions(), sizes.fVSize);
        if (hasCustomData) {
            size_t customDataSize = 0;
            buffer.skipByteArray(&customDataSize);
            if (customDataSize != 0) {
                return nullptr;
            }
        }
        buffer.readByteArray(builder.texCoords(), sizes.fTSize);
        buffer.readByteArray(builder.colors(), sizes.fCSize);
        buffer.readByteArray(builder.indices(), sizes.fISize);
 
        if (!buffer.isValid()) {
            return nullptr;
        }
 
        if (indexCount > 0) {
            // validate that the indices are in range
            const uint16_t* indices = builder.indices();
            for (int i = 0; i < indexCount; ++i) {
                if (indices[i] >= (unsigned)vertexCount) {
                    return nullptr;
                }
            }
        }
 
        return builder.detach();
    };
 
    if (auto verts = decode(buffer)) {
        return verts;
    }
    buffer.validate(false);
    return nullptr;
}

encode()

void SkVerticesPriv::encode

(

SkWriteBuffer &

buffer

)

const

Definition at line 240 of file SkVertices.cpp.

                                                       {
    // packed has room for additional flags in the future
    uint32_t packed = static_cast<uint32_t>(fVertices->fMode);
    SkASSERT((packed & ~kMode_Mask) == 0);  // our mode fits in the mask bits
    if (fVertices->fTexs) {
        packed |= kHasTexs_Mask;
    }
    if (fVertices->fColors) {
        packed |= kHasColors_Mask;
    }
 
    SkVertices::Sizes sizes = fVertices->getSizes();
    SkASSERT(!sizes.fBuilderTriFanISize);
 
    // Header
    buffer.writeUInt(packed);
    buffer.writeInt(fVertices->fVertexCount);
    buffer.writeInt(fVertices->fIndexCount);
 
    // Data arrays
    buffer.writeByteArray(fVertices->fPositions, sizes.fVSize);
    buffer.writeByteArray(fVertices->fTexs, sizes.fTSize);
    buffer.writeByteArray(fVertices->fColors, sizes.fCSize);
    // if index-count is odd, we won't be 4-bytes aligned, so we call the pad version
    buffer.writeByteArray(fVertices->fIndices, sizes.fISize);
}

hasColors()

bool SkVerticesPriv::hasColors ( ) const

inline

Definition at line 27 of file SkVerticesPriv.h.

{ return SkToBool(fVertices->fColors); }

hasIndices()

bool SkVerticesPriv::hasIndices ( ) const

inline

Definition at line 29 of file SkVerticesPriv.h.

{ return SkToBool(fVertices->fIndices); }

hasTexCoords()

bool SkVerticesPriv::hasTexCoords ( ) const

inline

Definition at line 28 of file SkVerticesPriv.h.

{ return SkToBool(fVertices->fTexs); }

indexCount()

int SkVerticesPriv::indexCount ( ) const

inline

Definition at line 32 of file SkVerticesPriv.h.

{ return fVertices->fIndexCount; }

indices()

const uint16_t * SkVerticesPriv::indices ( ) const

inline

Definition at line 37 of file SkVerticesPriv.h.

{ return fVertices->fIndices; }

mode()

SkVertices::VertexMode SkVerticesPriv::mode ( ) const

inline

Definition at line 25 of file SkVerticesPriv.h.

{ return fVertices->fMode; }

positions()

const SkPoint * SkVerticesPriv::positions ( ) const

inline

Definition at line 34 of file SkVerticesPriv.h.

{ return fVertices->fPositions; }

texCoords()

const SkPoint * SkVerticesPriv::texCoords ( ) const

inline

Definition at line 35 of file SkVerticesPriv.h.

{ return fVertices->fTexs; }

vertexCount()

int SkVerticesPriv::vertexCount ( ) const

inline

Definition at line 31 of file SkVerticesPriv.h.

{ return fVertices->fVertexCount; }

Friends And Related Function Documentation

SkVertices

friend class SkVertices

friend

Definition at line 55 of file SkVerticesPriv.h.

---

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

• third_party/skia/src/core/SkVerticesPriv.h
• third_party/skia/src/core/SkVertices.cpp