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
|
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLFragmentShaderBuilder_DEFINED
#define GrGLFragmentShaderBuilder_DEFINED
#include "GrGLShaderBuilder.h"
class GrGLVarying;
/*
* This base class encapsulates the functionality which the GP uses to build fragment shaders
*/
class GrGLFragmentBuilder : public GrGLShaderBuilder {
public:
GrGLFragmentBuilder(GrGLProgramBuilder* program)
: INHERITED(program) {
fSubstageIndices.push_back(0);
}
virtual ~GrGLFragmentBuilder() {}
/**
* Use of these features may require a GLSL extension to be enabled. Shaders may not compile
* if code is added that uses one of these features without calling enableFeature()
*/
enum GLSLFeature {
kStandardDerivatives_GLSLFeature = 0,
kLastGLSLFeature = kStandardDerivatives_GLSLFeature
};
/**
* If the feature is supported then true is returned and any necessary #extension declarations
* are added to the shaders. If the feature is not supported then false will be returned.
*/
virtual bool enableFeature(GLSLFeature) = 0;
/**
* This returns a variable name to access the 2D, perspective correct version of the coords in
* the fragment shader. If the coordinates at index are 3-dimensional, it immediately emits a
* perspective divide into the fragment shader (xy / z) to convert them to 2D.
*/
virtual SkString ensureFSCoords2D(const GrGLProcessor::TransformedCoordsArray& coords,
int index) = 0;
/** Returns a variable name that represents the position of the fragment in the FS. The position
is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
virtual const char* fragmentPosition() = 0;
/**
* Fragment procs with child procs should call these functions before/after calling emitCode
* on a child proc.
*/
void onBeforeChildProcEmitCode();
void onAfterChildProcEmitCode();
int getChildNumberThisLevel() const {
if (fSubstageIndices.count() > 1) {
// second-to-last value in the fSubstageIndices stack is the index of the child proc
// at that level which is currently emitting code.
return fSubstageIndices[fSubstageIndices.count() - 2];
}
return -1;
}
const SkString& getMangleString() const { return fMangleString; }
SkString getMangleStringThisLevel() const {
SkString ret;
int childNumber = this->getChildNumberThisLevel();
if (childNumber >= 0) {
ret.printf("_c%d", childNumber);
}
return ret;
}
private:
/*
* State that tracks which child proc in the proc tree is currently emitting code. This is
* used to update the fMangleString, which is used to mangle the names of uniforms and functions
* emitted by the proc. fSubstageIndices is a stack: its count indicates how many levels deep
* we are in the tree, and its second-to-last value is the index of the child proc at that
* level which is currently emitting code. For example, if fSubstageIndices = [3, 1, 2, 0], that
* means we're currently emitting code for the base proc's 3rd child's 1st child's 2nd child.
*/
SkTArray<int> fSubstageIndices;
/*
* The mangle string is used to mangle the names of uniforms/functions emitted by the child
* procs so no duplicate uniforms/functions appear in the generated shader program. The mangle
* string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0],
* then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will
* have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's
* 1st child's 2nd child".
*/
SkString fMangleString;
friend class GrGLPathProcessor;
typedef GrGLShaderBuilder INHERITED;
};
/*
* Fragment processor's, in addition to all of the above, may need to use dst color so they use
* this builder to create their shader. Because this is the only shader builder the FP sees, we
* just call it FPShaderBuilder
*/
class GrGLXPFragmentBuilder : public GrGLFragmentBuilder {
public:
GrGLXPFragmentBuilder(GrGLProgramBuilder* program) : INHERITED(program) {}
/** Returns the variable name that holds the color of the destination pixel. This may be NULL if
no effect advertised that it will read the destination. */
virtual const char* dstColor() = 0;
/** Adds any necessary layout qualifiers in order to legalize the supplied blend equation with
this shader. It is only legal to call this method with an advanced blend equation, and only
if these equations are supported. */
virtual void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) = 0;
private:
typedef GrGLFragmentBuilder INHERITED;
};
// TODO rename to Fragment Builder
class GrGLFragmentShaderBuilder : public GrGLXPFragmentBuilder {
public:
typedef uint8_t DstReadKey;
typedef uint8_t FragPosKey;
/** Returns a key for adding code to read the dst texture color in service of effects that
require reading the dst. It must not return 0 because 0 indicates that there is no dst
texture at all (in which case this function should not be called). */
static DstReadKey KeyForDstRead(const GrTexture* dsttexture, const GrGLCaps&);
/** Returns a key for reading the fragment location. This should only be called if there is an
effect that will requires the fragment position. If the fragment position is not required,
the key is 0. */
static FragPosKey KeyForFragmentPosition(const GrRenderTarget* dst, const GrGLCaps&);
GrGLFragmentShaderBuilder(GrGLProgramBuilder* program, uint8_t fragPosKey);
// true public interface, defined explicitly in the abstract interfaces above
bool enableFeature(GLSLFeature) override;
virtual SkString ensureFSCoords2D(const GrGLProcessor::TransformedCoordsArray& coords,
int index) override;
const char* fragmentPosition() override;
const char* dstColor() override;
void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override;
private:
// Private public interface, used by GrGLProgramBuilder to build a fragment shader
void enableCustomOutput();
void enableSecondaryOutput();
const char* getPrimaryColorOutputName() const;
const char* getSecondaryColorOutputName() const;
bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds);
void bindFragmentShaderLocations(GrGLuint programID);
// As GLProcessors emit code, there are some conditions we need to verify. We use the below
// state to track this. The reset call is called per processor emitted.
bool hasReadDstColor() const { return fHasReadDstColor; }
bool hasReadFragmentPosition() const { return fHasReadFragmentPosition; }
void reset() {
fHasReadDstColor = false;
fHasReadFragmentPosition = false;
}
/*
* An internal call for GrGLProgramBuilder to use to add varyings to the vertex shader
*/
void addVarying(GrGLVarying*, GrSLPrecision);
/**
* Features that should only be enabled by GrGLFragmentShaderBuilder itself.
*/
enum GLSLPrivateFeature {
kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
kBlendEquationAdvanced_GLSLPrivateFeature,
kBlendFuncExtended_GLSLPrivateFeature,
kLastGLSLPrivateFeature = kBlendFuncExtended_GLSLPrivateFeature
};
// Interpretation of DstReadKey when generating code
enum {
kNoDstRead_DstReadKey = 0,
kYesDstRead_DstReadKeyBit = 0x1, // Set if we do a dst-copy-read.
kUseAlphaConfig_DstReadKeyBit = 0x2, // Set if dst-copy config is alpha only.
kTopLeftOrigin_DstReadKeyBit = 0x4, // Set if dst-copy origin is top-left.
};
// Interpretation of FragPosKey when generating code
enum {
kNoFragPosRead_FragPosKey = 0, // The fragment positition will not be needed.
kTopLeftFragPosRead_FragPosKey = 0x1,// Read frag pos relative to top-left.
kBottomLeftFragPosRead_FragPosKey = 0x2,// Read frag pos relative to bottom-left.
};
static const char* kDstTextureColorName;
bool fHasCustomColorOutput;
bool fHasSecondaryOutput;
bool fSetupFragPosition;
bool fTopLeftFragPosRead;
int fCustomColorOutputIndex;
// some state to verify shaders and effects are consistent, this is reset between effects by
// the program creator
bool fHasReadDstColor;
bool fHasReadFragmentPosition;
friend class GrGLProgramBuilder;
typedef GrGLXPFragmentBuilder INHERITED;
};
#endif
|
