You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
9.9 KiB
282 lines
9.9 KiB
/*
|
|
* 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
|