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
|
/*
* 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 "GrGLProcessor.h"
#include "GrDrawState.h"
#include "GrGpu.h"
#include "GrOptDrawState.h"
class GrGpuGL;
/** This class describes a program to generate. It also serves as a program cache key. Very little
of this is GL-specific. The GL-specific parts could be factored out into a subclass. */
class GrGLProgramDesc {
public:
GrGLProgramDesc() {}
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 {
return reinterpret_cast<const uint32_t*>(fKey.begin());
}
// 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>(); }
/**
* Builds a program descriptor from a GrOptDrawState. Whether the primitive type is points, and
* the caps of the GrGpuGL are also inputs. It also outputs the color and coverage stages
* referenced by the generated descriptor. Coverage stages from the drawState may be treated as
* color stages in the output.
*/
static bool Build(const GrOptDrawState&,
GrGpu::DrawType,
GrGpuGL*,
const GrDeviceCoordTexture*,
GrGLProgramDesc*);
bool hasGeometryProcessor() const {
return SkToBool(this->getHeader().fHasGeometryProcessor);
}
int numColorEffects() const {
return this->getHeader().fColorEffectCnt;
}
int numCoverageEffects() const {
return this->getHeader().fCoverageEffectCnt;
}
int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
GrGLProgramDesc& operator= (const GrGLProgramDesc& other);
bool operator== (const GrGLProgramDesc& other) const {
// 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 {
kAllOnes_ColorInput,
kAttribute_ColorInput,
kUniform_ColorInput,
kColorInputCnt
};
struct KeyHeader {
uint8_t fDstReadKey; // set by GrGLShaderBuilder if there
// are effects that must read the dst.
// Otherwise, 0.
uint8_t fFragPosKey; // set by GrGLShaderBuilder if there are
// effects that read the fragment position.
// Otherwise, 0.
SkBool8 fUseFragShaderOnly;
SkBool8 fEmitsPointSize;
ColorInput fColorInput : 8;
ColorInput fCoverageInput : 8;
GrOptDrawState::PrimaryOutputType fPrimaryOutputType : 8;
GrOptDrawState::SecondaryOutputType fSecondaryOutputType : 8;
int8_t fPositionAttributeIndex;
int8_t fLocalCoordAttributeIndex;
int8_t fColorAttributeIndex;
int8_t fCoverageAttributeIndex;
SkBool8 fHasGeometryProcessor;
int8_t fColorEffectCnt;
int8_t fCoverageEffectCnt;
};
// The key, stored in fKey, is composed of five parts:
// 1. uint32_t for total key length.
// 2. uint32_t for a checksum.
// 3. Header struct defined above.
// 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each
// offset and size.
// 5. per-effect keys. Each effect's key is a variable length array of uint32_t.
enum {
// Part 1.
kLengthOffset = 0,
// Part 2.
kChecksumOffset = kLengthOffset + sizeof(uint32_t),
// Part 3.
kHeaderOffset = kChecksumOffset + sizeof(uint32_t),
kHeaderSize = SkAlign4(sizeof(KeyHeader)),
// Part 4.
// This is the offset in the overall key to the array of per-effect offset,length pairs.
kEffectKeyOffsetsAndLengthOffset = kHeaderOffset + kHeaderSize,
};
template<typename T, size_t OFFSET> T* atOffset() {
return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
}
template<typename T, size_t OFFSET> const T* atOffset() const {
return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
}
KeyHeader* header() { return this->atOffset<KeyHeader, kHeaderOffset>(); }
// a helper class to handle getting an individual processor's key
template <class ProcessorKeyBuilder>
static bool BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
const GrGLCaps& caps,
bool requiresLocalCoordAttrib,
GrGLProgramDesc* desc,
int* offsetAndSizeIndex);
void finalize();
const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
/** Used to provide effects' keys to their emitCode() function. */
class ProcKeyProvider {
public:
enum ProcessorType {
kGeometry_ProcessorType,
kFragment_ProcessorType,
};
ProcKeyProvider(const GrGLProgramDesc* desc, ProcessorType type)
: fDesc(desc), fBaseIndex(0) {
switch (type) {
case kGeometry_ProcessorType:
// there can be only one
fBaseIndex = 0;
break;
case kFragment_ProcessorType:
fBaseIndex = desc->hasGeometryProcessor() ? 1 : 0;
break;
}
}
GrProcessorKey get(int index) const {
const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>(
fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset);
// We store two uint16_ts per effect, one for the offset to the effect's key and one for
// its length. Here we just need the offset.
uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0];
uint16_t length = offsetsAndLengths[2 * (fBaseIndex + index) + 1];
// Currently effects must add to the key in units of uint32_t.
SkASSERT(0 == (length % sizeof(uint32_t)));
return GrProcessorKey(reinterpret_cast<const uint32_t*>(fDesc->fKey.begin() + offset),
length / sizeof(uint32_t));
}
private:
const GrGLProgramDesc* fDesc;
int fBaseIndex;
};
enum {
kMaxPreallocEffects = 8,
kIntsPerEffect = 4, // This is an overestimate of the average effect key size.
kPreAllocSize = kEffectKeyOffsetsAndLengthOffset +
kMaxPreallocEffects * sizeof(uint32_t) * kIntsPerEffect,
};
SkSTArray<kPreAllocSize, uint8_t, true> fKey;
// GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Split out
// part of GrGLShaderBuilder that is used by effects so that this header doesn't need to be
// visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
friend class GrGLProgram;
friend class GrGLProgramBuilder;
friend class GrGLLegacyNvprProgramBuilder;
friend class GrGLVertexBuilder;
friend class GrGLFragmentShaderBuilder;
friend class GrGLGeometryBuilder;
};
#endif
|
