/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkVertices_DEFINED
#define SkVertices_DEFINED
#include "SkColor.h"
#include "SkData.h"
#include "SkPoint.h"
#include "SkRect.h"
#include "SkRefCnt.h"
/**
* An immutable set of vertex data that can be used with SkCanvas::drawVertices.
*/
class SK_API SkVertices : public SkNVRefCnt<SkVertices> {
public:
// BoneIndices indicates which (of a maximum of 4 bones) a given vertex will interpolate
// between. To indicate that a slot is not used, the convention is to assign the bone index
// to 0.
struct BoneIndices {
uint32_t indices[4];
uint32_t& operator[] (int i) {
SkASSERT(i >= 0);
SkASSERT(i < 4);
return indices[i];
}
const uint32_t& operator[] (int i) const {
SkASSERT(i >= 0);
SkASSERT(i < 4);
return indices[i];
}
};
// BoneWeights stores the interpolation weight for each of the (maximum of 4) bones a given
// vertex interpolates between. To indicate that a slot is not used, the weight for that
// slot should be 0.
struct BoneWeights {
float weights[4];
float& operator[] (int i) {
SkASSERT(i >= 0);
SkASSERT(i < 4);
return weights[i];
}
const float& operator[] (int i) const {
SkASSERT(i >= 0);
SkASSERT(i < 4);
return weights[i];
}
};
// Bone stores a 3x2 transformation matrix in column major order:
// | scaleX skewX transX |
// | skewY scaleY transY |
// SkRSXform is insufficient because bones can have non uniform scale.
struct Bone {
float values[6];
float& operator[] (int i) {
SkASSERT(i >= 0);
SkASSERT(i < 6);
return values[i];
}
const float& operator[] (int i) const {
SkASSERT(i >= 0);
SkASSERT(i < 6);
return values[i];
}
SkPoint mapPoint(const SkPoint& point) const {
float x = values[0] * point.x() + values[2] * point.y() + values[4];
float y = values[1] * point.x() + values[3] * point.y() + values[5];
return SkPoint::Make(x, y);
}
SkRect mapRect(const SkRect& rect) const {
SkRect dst = SkRect::MakeEmpty();
SkPoint quad[4];
rect.toQuad(quad);
for (int i = 0; i < 4; i ++) {
quad[i] = mapPoint(quad[i]);
}
dst.setBoundsNoCheck(quad, 4);
return dst;
}
};
enum VertexMode {
kTriangles_VertexMode,
kTriangleStrip_VertexMode,
kTriangleFan_VertexMode,
kLast_VertexMode = kTriangleFan_VertexMode,
};
/**
* Create a vertices by copying the specified arrays. texs, colors, boneIndices, and
* boneWeights may be nullptr, and indices is ignored if indexCount == 0.
*
* boneIndices and boneWeights must either both be nullptr or both point to valid data.
* If specified, they must both contain 'vertexCount' entries.
*/
static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
const SkPoint positions[],
const SkPoint texs[],
const SkColor colors[],
const BoneIndices boneIndices[],
const BoneWeights boneWeights[],
int indexCount,
const uint16_t indices[],
bool isVolatile = true);
static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
const SkPoint positions[],
const SkPoint texs[],
const SkColor colors[],
const BoneIndices boneIndices[],
const BoneWeights boneWeights[],
bool isVolatile = true) {
return MakeCopy(mode,
vertexCount,
positions,
texs,
colors,
boneIndices,
boneWeights,
0,
nullptr,
isVolatile);
}
static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
const SkPoint positions[],
const SkPoint texs[],
const SkColor colors[],
int indexCount,
const uint16_t indices[],
bool isVolatile = true) {
return MakeCopy(mode,
vertexCount,
positions,
texs,
colors,
nullptr,
nullptr,
indexCount,
indices,
isVolatile);
}
static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
const SkPoint positions[],
const SkPoint texs[],
const SkColor colors[],
bool isVolatile = true) {
return MakeCopy(mode, vertexCount, positions, texs, colors, nullptr, nullptr, isVolatile);
}
struct Sizes;
enum BuilderFlags {
kHasTexCoords_BuilderFlag = 1 << 0,
kHasColors_BuilderFlag = 1 << 1,
kHasBones_BuilderFlag = 1 << 2,
kIsNonVolatile_BuilderFlag = 1 << 3,
};
class Builder {
public:
Builder(VertexMode mode, int vertexCount, int indexCount, uint32_t flags);
bool isValid() const { return fVertices != nullptr; }
// if the builder is invalid, these will return 0
int vertexCount() const;
int indexCount() const;
bool isVolatile() const;
SkPoint* positions();
SkPoint* texCoords(); // returns null if there are no texCoords
SkColor* colors(); // returns null if there are no colors
BoneIndices* boneIndices(); // returns null if there are no bone indices
BoneWeights* boneWeights(); // returns null if there are no bone weights
uint16_t* indices(); // returns null if there are no indices
// Detach the built vertices object. After the first call, this will always return null.
sk_sp<SkVertices> detach();
private:
Builder(VertexMode mode, int vertexCount, int indexCount, bool isVolatile, const Sizes&);
void init(VertexMode mode, int vertexCount, int indexCount, bool isVolatile, const Sizes&);
// holds a partially complete object. only completed in detach()
sk_sp<SkVertices> fVertices;
// Extra storage for intermediate vertices in the case where the client specifies indexed
// triangle fans. These get converted to indexed triangles when the Builder is finalized.
std::unique_ptr<uint8_t[]> fIntermediateFanIndices;
friend class SkVertices;
};
uint32_t uniqueID() const { return fUniqueID; }
VertexMode mode() const { return fMode; }
const SkRect& bounds() const { return fBounds; }
bool hasColors() const { return SkToBool(this->colors()); }
bool hasTexCoords() const { return SkToBool(this->texCoords()); }
bool hasBones() const { return SkToBool(this->boneIndices()); }
bool hasIndices() const { return SkToBool(this->indices()); }
int vertexCount() const { return fVertexCnt; }
const SkPoint* positions() const { return fPositions; }
const SkPoint* texCoords() const { return fTexs; }
const SkColor* colors() const { return fColors; }
const BoneIndices* boneIndices() const { return fBoneIndices; }
const BoneWeights* boneWeights() const { return fBoneWeights; }
int indexCount() const { return fIndexCnt; }
const uint16_t* indices() const { return fIndices; }
bool isVolatile() const { return fIsVolatile; }
sk_sp<SkVertices> applyBones(const Bone bones[], int boneCount) const;
// returns approximate byte size of the vertices object
size_t approximateSize() const;
/**
* Recreate a vertices from a buffer previously created by calling encode().
* Returns null if the data is corrupt or the length is incorrect for the contents.
*/
static sk_sp<SkVertices> Decode(const void* buffer, size_t length);
/**
* Pack the vertices object into a byte buffer. This can be used to recreate the vertices
* by calling Decode() with the buffer.
*/
sk_sp<SkData> encode() const;
private:
SkVertices() {}
// these are needed since we've manually sized our allocation (see Builder::init)
friend class SkNVRefCnt<SkVertices>;
void operator delete(void* p);
static sk_sp<SkVertices> Alloc(int vCount, int iCount, uint32_t builderFlags,
size_t* arraySize);
// we store this first, to pair with the refcnt in our base-class, so we don't have an
// unnecessary pad between it and the (possibly 8-byte aligned) ptrs.
uint32_t fUniqueID;
// these point inside our allocation, so none of these can be "freed"
SkPoint* fPositions;
SkPoint* fTexs;
SkColor* fColors;
BoneIndices* fBoneIndices;
BoneWeights* fBoneWeights;
uint16_t* fIndices;
SkRect fBounds; // computed to be the union of the fPositions[]
int fVertexCnt;
int fIndexCnt;
bool fIsVolatile;
VertexMode fMode;
// below here is where the actual array data is stored.
};
#endif