1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef gr_instanced_InstancedRenderingTypes_DEFINED
#define gr_instanced_InstancedRenderingTypes_DEFINED
#include "GrTypes.h"
#include "SkRRect.h"
namespace gr_instanced {
/**
* Per-vertex data. These values get fed into normal vertex attribs.
*/
struct ShapeVertex {
float fX, fY; //!< Shape coordinates.
int32_t fAttrs; //!< Shape-specific vertex attributes, if needed.
};
/**
* Per-instance data. These values get fed into instanced vertex attribs.
*/
struct Instance {
uint32_t fInfo; //!< Packed info about the instance. See InfoBits.
float fShapeMatrix2x3[6]; //!< Maps canonical shape coords -> device space coords.
uint32_t fColor; //!< Color to be written out by the primitive processor.
float fLocalRect[4]; //!< Local coords rect that spans [-1, +1] in shape coords.
};
enum class Attrib : uint8_t {
kShapeCoords,
kVertexAttrs,
kInstanceInfo,
kShapeMatrixX,
kShapeMatrixY,
kColor,
kLocalRect
};
constexpr int kNumAttribs = 1 + (int)Attrib::kLocalRect;
enum class AntialiasMode : uint8_t {
kNone,
kCoverage,
kMSAA,
kMixedSamples
};
constexpr int kNumAntialiasModes = 1 + (int)AntialiasMode::kMixedSamples;
enum class ShapeType : uint8_t {
kRect,
kOval,
kSimpleRRect,
kNinePatch,
kComplexRRect
};
constexpr int kNumShapeTypes = 1 + (int)ShapeType::kComplexRRect;
inline static ShapeType GetRRectShapeType(const SkRRect& rrect) {
SkASSERT(rrect.getType() >= SkRRect::kRect_Type &&
rrect.getType() <= SkRRect::kComplex_Type);
return static_cast<ShapeType>(rrect.getType() - 1);
GR_STATIC_ASSERT((int)ShapeType::kRect == SkRRect::kRect_Type - 1);
GR_STATIC_ASSERT((int)ShapeType::kOval == SkRRect::kOval_Type - 1);
GR_STATIC_ASSERT((int)ShapeType::kSimpleRRect == SkRRect::kSimple_Type - 1);
GR_STATIC_ASSERT((int)ShapeType::kNinePatch == SkRRect::kNinePatch_Type - 1);
GR_STATIC_ASSERT((int)ShapeType::kComplexRRect == SkRRect::kComplex_Type - 1);
GR_STATIC_ASSERT(kNumShapeTypes == SkRRect::kComplex_Type);
}
enum ShapeFlag {
kRect_ShapeFlag = (1 << (int)ShapeType::kRect),
kOval_ShapeFlag = (1 << (int)ShapeType::kOval),
kSimpleRRect_ShapeFlag = (1 << (int)ShapeType::kSimpleRRect),
kNinePatch_ShapeFlag = (1 << (int)ShapeType::kNinePatch),
kComplexRRect_ShapeFlag = (1 << (int)ShapeType::kComplexRRect),
kRRect_ShapesMask = kSimpleRRect_ShapeFlag | kNinePatch_ShapeFlag | kComplexRRect_ShapeFlag
};
constexpr uint8_t GetShapeFlag(ShapeType type) { return 1 << (int)type; }
/**
* Defines what data is stored at which bits in the fInfo field of the instanced data.
*/
enum InfoBits {
kShapeType_InfoBit = 29,
kInnerShapeType_InfoBit = 27,
kPerspective_InfoBit = 26,
kLocalMatrix_InfoBit = 25,
kParamsIdx_InfoBit = 0
};
enum InfoMasks {
kShapeType_InfoMask = 0u - (1 << kShapeType_InfoBit),
kInnerShapeType_InfoMask = (1 << kShapeType_InfoBit) - (1 << kInnerShapeType_InfoBit),
kPerspective_InfoFlag = (1 << kPerspective_InfoBit),
kLocalMatrix_InfoFlag = (1 << kLocalMatrix_InfoBit),
kParamsIdx_InfoMask = (1 << kLocalMatrix_InfoBit) - 1
};
GR_STATIC_ASSERT((kNumShapeTypes - 1) <= (uint32_t)kShapeType_InfoMask >> kShapeType_InfoBit);
GR_STATIC_ASSERT((int)ShapeType::kSimpleRRect <=
kInnerShapeType_InfoMask >> kInnerShapeType_InfoBit);
/**
* Additional parameters required by some instances (e.g. round rect radii, perspective column,
* local matrix). These are accessed via texel buffer.
*/
struct ParamsTexel {
float fX, fY, fZ, fW;
};
GR_STATIC_ASSERT(0 == offsetof(ParamsTexel, fX));
GR_STATIC_ASSERT(4 * 4 == sizeof(ParamsTexel));
/**
* Tracks all information needed in order to draw a batch of instances. This struct also serves
* as an all-in-one shader key for the batch.
*/
struct BatchInfo {
BatchInfo() : fData(0) {}
explicit BatchInfo(uint32_t data) : fData(data) {}
static bool CanCombine(const BatchInfo& a, const BatchInfo& b);
bool isSimpleRects() const {
return !((fShapeTypes & ~kRect_ShapeFlag) | fInnerShapeTypes);
}
union {
struct {
AntialiasMode fAntialiasMode;
uint8_t fShapeTypes;
uint8_t fInnerShapeTypes;
bool fHasPerspective : 1;
bool fHasLocalMatrix : 1;
bool fHasParams : 1;
bool fNonSquare : 1;
bool fUsesLocalCoords : 1;
bool fCannotTweakAlphaForCoverage : 1;
bool fCannotDiscard : 1;
};
uint32_t fData;
};
};
inline bool BatchInfo::CanCombine(const BatchInfo& a, const BatchInfo& b) {
if (a.fAntialiasMode != b.fAntialiasMode) {
return false;
}
if (SkToBool(a.fInnerShapeTypes) != SkToBool(b.fInnerShapeTypes)) {
// GrInstanceProcessor can't currently combine draws with and without inner shapes.
return false;
}
if (a.fCannotDiscard != b.fCannotDiscard) {
// For stencil draws, the use of discard can be a requirement.
return false;
}
return true;
}
inline BatchInfo operator|(const BatchInfo& a, const BatchInfo& b) {
SkASSERT(BatchInfo::CanCombine(a, b));
return BatchInfo(a.fData | b.fData);
}
// This is required since all the data must fit into 32 bits of a shader key.
GR_STATIC_ASSERT(sizeof(uint32_t) == sizeof(BatchInfo));
GR_STATIC_ASSERT(kNumShapeTypes <= 8);
struct IndexRange {
bool operator ==(const IndexRange& that) const {
SkASSERT(fStart != that.fStart || fCount == that.fCount);
return fStart == that.fStart;
}
bool operator !=(const IndexRange& that) const { return !(*this == that); }
bool isEmpty() const { return fCount <= 0; }
int end() { return fStart + fCount; }
int16_t fStart;
int16_t fCount;
};
}
#endif
|
