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
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
/*
* 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 SKSL_PROGRAM
#define SKSL_PROGRAM
#include <vector>
#include <memory>
#include "SkSLBoolLiteral.h"
#include "SkSLExpression.h"
#include "SkSLIntLiteral.h"
#include "SkSLModifiers.h"
#include "SkSLProgramElement.h"
#include "SkSLSymbolTable.h"
// name of the render target height uniform
#define SKSL_RTHEIGHT_NAME "u_skRTHeight"
namespace SkSL {
class Context;
/**
* Represents a fully-digested program, ready for code generation.
*/
struct Program {
struct Settings {
struct Value {
Value(bool b)
: fKind(kBool_Kind)
, fValue(b) {}
Value(int i)
: fKind(kInt_Kind)
, fValue(i) {}
std::unique_ptr<Expression> literal(const Context& context, int offset) const {
switch (fKind) {
case Program::Settings::Value::kBool_Kind:
return std::unique_ptr<Expression>(new BoolLiteral(context,
offset,
fValue));
case Program::Settings::Value::kInt_Kind:
return std::unique_ptr<Expression>(new IntLiteral(context,
offset,
fValue));
default:
SkASSERT(false);
return nullptr;
}
}
enum {
kBool_Kind,
kInt_Kind,
} fKind;
int fValue;
};
#ifdef SKSL_STANDALONE
const StandaloneShaderCaps* fCaps = &standaloneCaps;
#else
const GrShaderCaps* fCaps = nullptr;
#endif
// if false, sk_FragCoord is exactly the same as gl_FragCoord. If true, the y coordinate
// must be flipped.
bool fFlipY = false;
// If true the destination fragment color is read sk_FragColor. It must be declared inout.
bool fFragColorIsInOut = false;
// if true, Setting objects (e.g. sk_Caps.fbFetchSupport) should be replaced with their
// constant equivalents during compilation
bool fReplaceSettings = true;
// if true, all halfs are forced to be floats
bool fForceHighPrecision = false;
// if true, add -0.5 bias to LOD of all texture lookups
bool fSharpenTextures = false;
std::unordered_map<String, Value> fArgs;
};
struct Inputs {
// if true, this program requires the render target height uniform to be defined
bool fRTHeight;
// if true, this program must be recompiled if the flipY setting changes. If false, the
// program will compile to the same code regardless of the flipY setting.
bool fFlipY;
void reset() {
fRTHeight = false;
fFlipY = false;
}
bool isEmpty() {
return !fRTHeight && !fFlipY;
}
};
class iterator {
public:
ProgramElement& operator*() {
if (fIter1 != fEnd1) {
return **fIter1;
}
return **fIter2;
}
iterator& operator++() {
if (fIter1 != fEnd1) {
++fIter1;
return *this;
}
++fIter2;
return *this;
}
bool operator==(const iterator& other) const {
return fIter1 == other.fIter1 && fIter2 == other.fIter2;
}
bool operator!=(const iterator& other) const {
return !(*this == other);
}
private:
using inner = std::vector<std::unique_ptr<ProgramElement>>::iterator;
iterator(inner begin1, inner end1, inner begin2, inner end2)
: fIter1(begin1)
, fEnd1(end1)
, fIter2(begin2)
, fEnd2(end2) {}
inner fIter1;
inner fEnd1;
inner fIter2;
inner fEnd2;
friend struct Program;
};
class const_iterator {
public:
const ProgramElement& operator*() {
if (fIter1 != fEnd1) {
return **fIter1;
}
return **fIter2;
}
const_iterator& operator++() {
if (fIter1 != fEnd1) {
++fIter1;
return *this;
}
++fIter2;
return *this;
}
bool operator==(const const_iterator& other) const {
return fIter1 == other.fIter1 && fIter2 == other.fIter2;
}
bool operator!=(const const_iterator& other) const {
return !(*this == other);
}
private:
using inner = std::vector<std::unique_ptr<ProgramElement>>::const_iterator;
const_iterator(inner begin1, inner end1, inner begin2, inner end2)
: fIter1(begin1)
, fEnd1(end1)
, fIter2(begin2)
, fEnd2(end2) {}
inner fIter1;
inner fEnd1;
inner fIter2;
inner fEnd2;
friend struct Program;
};
enum Kind {
kFragment_Kind,
kVertex_Kind,
kGeometry_Kind,
kFragmentProcessor_Kind,
kCPU_Kind
};
Program(Kind kind,
std::unique_ptr<String> source,
Settings settings,
std::shared_ptr<Context> context,
std::vector<std::unique_ptr<ProgramElement>>* inheritedElements,
std::vector<std::unique_ptr<ProgramElement>> elements,
std::shared_ptr<SymbolTable> symbols,
Inputs inputs)
: fKind(kind)
, fSource(std::move(source))
, fSettings(settings)
, fContext(context)
, fSymbols(symbols)
, fInputs(inputs)
, fInheritedElements(inheritedElements)
, fElements(std::move(elements)) {}
iterator begin() {
if (fInheritedElements) {
return iterator(fInheritedElements->begin(), fInheritedElements->end(),
fElements.begin(), fElements.end());
}
return iterator(fElements.begin(), fElements.end(), fElements.end(), fElements.end());
}
iterator end() {
if (fInheritedElements) {
return iterator(fInheritedElements->end(), fInheritedElements->end(),
fElements.end(), fElements.end());
}
return iterator(fElements.end(), fElements.end(), fElements.end(), fElements.end());
}
const_iterator begin() const {
if (fInheritedElements) {
return const_iterator(fInheritedElements->begin(), fInheritedElements->end(),
fElements.begin(), fElements.end());
}
return const_iterator(fElements.begin(), fElements.end(), fElements.end(), fElements.end());
}
const_iterator end() const {
if (fInheritedElements) {
return const_iterator(fInheritedElements->end(), fInheritedElements->end(),
fElements.end(), fElements.end());
}
return const_iterator(fElements.end(), fElements.end(), fElements.end(), fElements.end());
}
Kind fKind;
std::unique_ptr<String> fSource;
Settings fSettings;
std::shared_ptr<Context> fContext;
// it's important to keep fElements defined after (and thus destroyed before) fSymbols,
// because destroying elements can modify reference counts in symbols
std::shared_ptr<SymbolTable> fSymbols;
Inputs fInputs;
private:
std::vector<std::unique_ptr<ProgramElement>>* fInheritedElements;
std::vector<std::unique_ptr<ProgramElement>> fElements;
};
} // namespace
#endif
|
