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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLProgramDesc_DEFINED
#define GrGLProgramDesc_DEFINED
#include "GrGLEffect.h"
#include "GrDrawState.h"
#include "GrGLShaderBuilder.h"
class GrGpuGL;
#ifdef SK_DEBUG
// Optionally compile the experimental GS code. Set to SK_DEBUG so that debug build bots will
// execute the code.
#define GR_GL_EXPERIMENTAL_GS 1
#else
#define GR_GL_EXPERIMENTAL_GS 0
#endif
/** This class describes a program to generate. It also serves as a program cache key. Very little
of this is GL-specific. There is the generation of GrGLEffect::EffectKeys and the dst-read part
of the key set by GrGLShaderBuilder. If the interfaces that set those portions were abstracted
to be API-neutral then so could this class. */
class GrGLProgramDesc {
public:
GrGLProgramDesc() : fInitialized(false) {}
GrGLProgramDesc(const GrGLProgramDesc& desc) { *this = desc; }
// Returns this as a uint32_t array to be used as a key in the program cache.
const uint32_t* asKey() const {
SkASSERT(fInitialized);
return reinterpret_cast<const uint32_t*>(fKey.get());
}
// Gets the number of bytes in asKey(). It will be a 4-byte aligned value. When comparing two
// keys the size of either key can be used with memcmp() since the lengths themselves begin the
// keys and thus the memcmp will exit early if the keys are of different lengths.
uint32_t keyLength() const { return *this->atOffset<uint32_t, kLengthOffset>(); }
// Gets the a checksum of the key. Can be used as a hash value for a fast lookup in a cache.
uint32_t getChecksum() const { return *this->atOffset<uint32_t, kChecksumOffset>(); }
// For unit testing.
void setRandom(SkRandom*,
const GrGpuGL* gpu,
const GrRenderTarget* dummyDstRenderTarget,
const GrTexture* dummyDstCopyTexture,
const GrEffectStage* stages[],
int numColorStages,
int numCoverageStages,
int currAttribIndex);
/**
* Builds a program descriptor from a GrDrawState. Whether the primitive type is points, the
* output of GrDrawState::getBlendOpts, and the caps of the GrGpuGL are also inputs. It also
* outputs the color and coverage stages referenced by the generated descriptor. This may
* not contain all stages from the draw state and coverage stages from the drawState may
* be treated as color stages in the output.
*/
static void Build(const GrDrawState&,
bool isPoints,
GrDrawState::BlendOptFlags,
GrBlendCoeff srcCoeff,
GrBlendCoeff dstCoeff,
const GrGpuGL* gpu,
const GrDeviceCoordTexture* dstCopy,
SkTArray<const GrEffectStage*, true>* outColorStages,
SkTArray<const GrEffectStage*, true>* outCoverageStages,
GrGLProgramDesc* outDesc);
int numColorEffects() const {
SkASSERT(fInitialized);
return this->getHeader().fColorEffectCnt;
}
int numCoverageEffects() const {
SkASSERT(fInitialized);
return this->getHeader().fCoverageEffectCnt;
}
int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
GrGLProgramDesc& operator= (const GrGLProgramDesc& other);
bool operator== (const GrGLProgramDesc& other) const {
SkASSERT(fInitialized && other.fInitialized);
// The length is masked as a hint to the compiler that the address will be 4 byte aligned.
return 0 == memcmp(this->asKey(), other.asKey(), this->keyLength() & ~0x3);
}
bool operator!= (const GrGLProgramDesc& other) const {
return !(*this == other);
}
static bool Less(const GrGLProgramDesc& a, const GrGLProgramDesc& b) {
return memcmp(a.asKey(), b.asKey(), a.keyLength() & ~0x3) < 0;
}
private:
// Specifies where the initial color comes from before the stages are applied.
enum ColorInput {
kSolidWhite_ColorInput,
kTransBlack_ColorInput,
kAttribute_ColorInput,
kUniform_ColorInput,
kColorInputCnt
};
enum CoverageOutput {
// modulate color and coverage, write result as the color output.
kModulate_CoverageOutput,
// Writes color*coverage as the primary color output and also writes coverage as the
// secondary output. Only set if dual source blending is supported.
kSecondaryCoverage_CoverageOutput,
// Writes color*coverage as the primary color output and also writes coverage * (1 - colorA)
// as the secondary output. Only set if dual source blending is supported.
kSecondaryCoverageISA_CoverageOutput,
// Writes color*coverage as the primary color output and also writes coverage *
// (1 - colorRGB) as the secondary output. Only set if dual source blending is supported.
kSecondaryCoverageISC_CoverageOutput,
// Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This
// can only be set if fDstReadKey is non-zero.
kCombineWithDst_CoverageOutput,
kCoverageOutputCnt
};
static bool CoverageOutputUsesSecondaryOutput(CoverageOutput co) {
switch (co) {
case kSecondaryCoverage_CoverageOutput: // fallthru
case kSecondaryCoverageISA_CoverageOutput:
case kSecondaryCoverageISC_CoverageOutput:
return true;
default:
return false;
}
}
struct KeyHeader {
GrGLShaderBuilder::DstReadKey fDstReadKey; // set by GrGLShaderBuilder if there
// are effects that must read the dst.
// Otherwise, 0.
GrGLShaderBuilder::FragPosKey fFragPosKey; // set by GrGLShaderBuilder if there are
// effects that read the fragment position.
// Otherwise, 0.
ColorInput fColorInput : 8;
ColorInput fCoverageInput : 8;
CoverageOutput fCoverageOutput : 8;
SkBool8 fHasVertexCode;
SkBool8 fEmitsPointSize;
// To enable experimental geometry shader code (not for use in
// production)
#if GR_GL_EXPERIMENTAL_GS
SkBool8 fExperimentalGS;
#endif
int8_t fPositionAttributeIndex;
int8_t fLocalCoordAttributeIndex;
int8_t fColorAttributeIndex;
int8_t fCoverageAttributeIndex;
int8_t fColorEffectCnt;
int8_t fCoverageEffectCnt;
};
// The key is 1 uint32_t for the length, followed another for the checksum, the header, and then
// the effect keys. Everything is fixed length except the effect key array.
enum {
kLengthOffset = 0,
kChecksumOffset = kLengthOffset + sizeof(uint32_t),
kHeaderOffset = kChecksumOffset + sizeof(uint32_t),
kHeaderSize = SkAlign4(sizeof(KeyHeader)),
kEffectKeyOffset = kHeaderOffset + kHeaderSize,
};
template<typename T, size_t OFFSET> T* atOffset() {
return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.get()) + OFFSET);
}
template<typename T, size_t OFFSET> const T* atOffset() const {
return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.get()) + OFFSET);
}
typedef GrGLEffect::EffectKey EffectKey;
uint32_t* checksum() { return this->atOffset<uint32_t, kChecksumOffset>(); }
KeyHeader* header() { return this->atOffset<KeyHeader, kHeaderOffset>(); }
EffectKey* effectKeys() { return this->atOffset<EffectKey, kEffectKeyOffset>(); }
const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
const EffectKey* getEffectKeys() const { return this->atOffset<EffectKey, kEffectKeyOffset>(); }
static size_t KeyLength(int effectCnt) {
GR_STATIC_ASSERT(!(sizeof(EffectKey) & 0x3));
return kEffectKeyOffset + effectCnt * sizeof(EffectKey);
}
enum {
kMaxPreallocEffects = 16,
kPreAllocSize = kEffectKeyOffset + kMaxPreallocEffects * sizeof(EffectKey),
};
SkAutoSMalloc<kPreAllocSize> fKey;
bool fInitialized;
// GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Move all
// code generation to GrGLShaderBuilder (and maybe add getters rather than friending).
friend class GrGLProgram;
friend class GrGLShaderBuilder;
friend class GrGLFullShaderBuilder;
friend class GrGLFragmentOnlyShaderBuilder;
};
#endif
|
