1 | /* |
2 | * Copyright 2014 Google Inc. |
3 | * |
4 | * Use of this source code is governed by a BSD-style license that can be |
5 | * found in the LICENSE file. |
6 | */ |
7 | |
8 | #ifndef GrGLSLFragmentShaderBuilder_DEFINED |
9 | #define GrGLSLFragmentShaderBuilder_DEFINED |
10 | |
11 | #include "src/gpu/GrBlend.h" |
12 | #include "src/gpu/GrProcessor.h" |
13 | #include "src/gpu/glsl/GrGLSLFragmentProcessor.h" |
14 | #include "src/gpu/glsl/GrGLSLShaderBuilder.h" |
15 | |
16 | class GrRenderTarget; |
17 | class GrGLSLVarying; |
18 | |
19 | /* |
20 | * This base class encapsulates the common functionality which all processors use to build fragment |
21 | * shaders. |
22 | */ |
23 | class GrGLSLFragmentBuilder : public GrGLSLShaderBuilder { |
24 | public: |
25 | GrGLSLFragmentBuilder(GrGLSLProgramBuilder* program) : INHERITED(program) {} |
26 | virtual ~GrGLSLFragmentBuilder() {} |
27 | |
28 | /** |
29 | * This returns a variable name to access the 2D, perspective correct version of the coords in |
30 | * the fragment shader. The passed in coordinates must either be of type kHalf2 or kHalf3. If |
31 | * the coordinates are 3-dimensional, it a perspective divide into is emitted into the |
32 | * fragment shader (xy / z) to convert them to 2D. |
33 | */ |
34 | virtual SkString ensureCoords2D(const GrShaderVar&) = 0; |
35 | |
36 | // TODO: remove this method. |
37 | void declAppendf(const char* fmt, ...); |
38 | |
39 | private: |
40 | typedef GrGLSLShaderBuilder INHERITED; |
41 | }; |
42 | |
43 | /* |
44 | * This class is used by fragment processors to build their fragment code. |
45 | */ |
46 | class GrGLSLFPFragmentBuilder : virtual public GrGLSLFragmentBuilder { |
47 | public: |
48 | /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */ |
49 | GrGLSLFPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) { |
50 | // Suppress unused warning error |
51 | (void) fDummyPadding; |
52 | } |
53 | |
54 | /** |
55 | * Returns the variable name that holds the array of sample offsets from pixel center to each |
56 | * sample location. Before this is called, a processor must have advertised that it will use |
57 | * CustomFeatures::kSampleLocations. |
58 | */ |
59 | virtual const char* sampleOffsets() = 0; |
60 | |
61 | enum class ScopeFlags { |
62 | // Every fragment will always execute this code, and will do it exactly once. |
63 | kTopLevel = 0, |
64 | // Either all fragments in a given primitive, or none, will execute this code. |
65 | kInsidePerPrimitiveBranch = (1 << 0), |
66 | // Any given fragment may or may not execute this code. |
67 | kInsidePerPixelBranch = (1 << 1), |
68 | // This code will be executed more than once. |
69 | kInsideLoop = (1 << 2) |
70 | }; |
71 | |
72 | /** |
73 | * Subtracts multisample coverage by AND-ing the sample mask with the provided "mask". |
74 | * Sample N corresponds to bit "1 << N". |
75 | * |
76 | * If the given scope is "kTopLevel" and the sample mask has not yet been modified, this method |
77 | * assigns the sample mask in place rather than pre-initializing it to ~0 then AND-ing it. |
78 | * |
79 | * Requires MSAA and GLSL support for sample variables. |
80 | */ |
81 | virtual void maskOffMultisampleCoverage(const char* mask, ScopeFlags) = 0; |
82 | |
83 | /** |
84 | * Turns off coverage at each sample where the implicit function fn > 0. |
85 | * |
86 | * The provided "fn" value represents the implicit function at pixel center. We then approximate |
87 | * the implicit at each sample by riding the gradient, "grad", linearly from pixel center to |
88 | * each sample location. |
89 | * |
90 | * If "grad" is null, we approximate the gradient using HW derivatives. |
91 | * |
92 | * Requires MSAA and GLSL support for sample variables. Also requires HW derivatives if not |
93 | * providing a gradient. |
94 | */ |
95 | virtual void applyFnToMultisampleMask(const char* fn, const char* grad, ScopeFlags) = 0; |
96 | |
97 | /** |
98 | * Fragment procs with child procs should call these functions before/after calling emitCode |
99 | * on a child proc. |
100 | */ |
101 | virtual void onBeforeChildProcEmitCode() = 0; |
102 | virtual void onAfterChildProcEmitCode() = 0; |
103 | |
104 | virtual SkString writeProcessorFunction(GrGLSLFragmentProcessor* fp, |
105 | GrGLSLFragmentProcessor::EmitArgs& args); |
106 | |
107 | virtual const SkString& getMangleString() const = 0; |
108 | |
109 | virtual void forceHighPrecision() = 0; |
110 | |
111 | private: |
112 | // WARNING: LIke GrRenderTargetProxy, changes to this can cause issues in ASAN. This is caused |
113 | // by GrGLSLProgramBuilder's GrTAllocators requiring 16 byte alignment, but since |
114 | // GrGLSLFragmentShaderBuilder has a virtual diamond hierarchy, ASAN requires all this pointers |
115 | // to start aligned, even though clang is already correctly offsetting the individual fields |
116 | // that require the larger alignment. In the current world, this extra padding is sufficient to |
117 | // correctly initialize GrGLSLXPFragmentBuilder second. |
118 | char fDummyPadding[4]; |
119 | }; |
120 | |
121 | GR_MAKE_BITFIELD_CLASS_OPS(GrGLSLFPFragmentBuilder::ScopeFlags); |
122 | |
123 | /* |
124 | * This class is used by Xfer processors to build their fragment code. |
125 | */ |
126 | class GrGLSLXPFragmentBuilder : virtual public GrGLSLFragmentBuilder { |
127 | public: |
128 | /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */ |
129 | GrGLSLXPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) {} |
130 | |
131 | virtual bool hasCustomColorOutput() const = 0; |
132 | virtual bool hasSecondaryOutput() const = 0; |
133 | |
134 | /** Returns the variable name that holds the color of the destination pixel. This may be nullptr |
135 | * if no effect advertised that it will read the destination. */ |
136 | virtual const char* dstColor() = 0; |
137 | |
138 | /** Adds any necessary layout qualifiers in order to legalize the supplied blend equation with |
139 | this shader. It is only legal to call this method with an advanced blend equation, and only |
140 | if these equations are supported. */ |
141 | virtual void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) = 0; |
142 | }; |
143 | |
144 | /* |
145 | * This class implements the various fragment builder interfaces. |
146 | */ |
147 | class GrGLSLFragmentShaderBuilder : public GrGLSLFPFragmentBuilder, public GrGLSLXPFragmentBuilder { |
148 | public: |
149 | /** Returns a nonzero key for a surface's origin. This should only be called if a processor will |
150 | use the fragment position and/or sample locations. */ |
151 | static uint8_t KeyForSurfaceOrigin(GrSurfaceOrigin); |
152 | |
153 | GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program); |
154 | |
155 | // Shared GrGLSLFragmentBuilder interface. |
156 | virtual SkString ensureCoords2D(const GrShaderVar&) override; |
157 | |
158 | // GrGLSLFPFragmentBuilder interface. |
159 | const char* sampleOffsets() override; |
160 | void maskOffMultisampleCoverage(const char* mask, ScopeFlags) override; |
161 | void applyFnToMultisampleMask(const char* fn, const char* grad, ScopeFlags) override; |
162 | const SkString& getMangleString() const override { return fMangleString; } |
163 | void onBeforeChildProcEmitCode() override; |
164 | void onAfterChildProcEmitCode() override; |
165 | void forceHighPrecision() override { fForceHighPrecision = true; } |
166 | |
167 | // GrGLSLXPFragmentBuilder interface. |
168 | bool hasCustomColorOutput() const override { return SkToBool(fCustomColorOutput); } |
169 | bool hasSecondaryOutput() const override { return fHasSecondaryOutput; } |
170 | const char* dstColor() override; |
171 | void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override; |
172 | |
173 | private: |
174 | using CustomFeatures = GrProcessor::CustomFeatures; |
175 | |
176 | // Private public interface, used by GrGLProgramBuilder to build a fragment shader |
177 | void enableCustomOutput(); |
178 | void enableSecondaryOutput(); |
179 | const char* getPrimaryColorOutputName() const; |
180 | const char* getSecondaryColorOutputName() const; |
181 | bool primaryColorOutputIsInOut() const; |
182 | |
183 | #ifdef SK_DEBUG |
184 | // As GLSLProcessors emit code, there are some conditions we need to verify. We use the below |
185 | // state to track this. The reset call is called per processor emitted. |
186 | bool fHasReadDstColorThisStage_DebugOnly = false; |
187 | CustomFeatures fUsedProcessorFeaturesThisStage_DebugOnly = CustomFeatures::kNone; |
188 | CustomFeatures fUsedProcessorFeaturesAllStages_DebugOnly = CustomFeatures::kNone; |
189 | |
190 | void debugOnly_resetPerStageVerification() { |
191 | fHasReadDstColorThisStage_DebugOnly = false; |
192 | fUsedProcessorFeaturesThisStage_DebugOnly = CustomFeatures::kNone; |
193 | } |
194 | #endif |
195 | |
196 | static const char* DeclaredColorOutputName() { return "sk_FragColor" ; } |
197 | static const char* DeclaredSecondaryColorOutputName() { return "fsSecondaryColorOut" ; } |
198 | |
199 | GrSurfaceOrigin getSurfaceOrigin() const; |
200 | |
201 | void onFinalize() override; |
202 | |
203 | static const char* kDstColorName; |
204 | |
205 | /* |
206 | * State that tracks which child proc in the proc tree is currently emitting code. This is |
207 | * used to update the fMangleString, which is used to mangle the names of uniforms and functions |
208 | * emitted by the proc. fSubstageIndices is a stack: its count indicates how many levels deep |
209 | * we are in the tree, and its second-to-last value is the index of the child proc at that |
210 | * level which is currently emitting code. For example, if fSubstageIndices = [3, 1, 2, 0], that |
211 | * means we're currently emitting code for the base proc's 3rd child's 1st child's 2nd child. |
212 | */ |
213 | SkTArray<int> fSubstageIndices; |
214 | |
215 | /* |
216 | * The mangle string is used to mangle the names of uniforms/functions emitted by the child |
217 | * procs so no duplicate uniforms/functions appear in the generated shader program. The mangle |
218 | * string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0], |
219 | * then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will |
220 | * have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's |
221 | * 1st child's 2nd child". |
222 | */ |
223 | SkString fMangleString; |
224 | |
225 | GrShaderVar* fCustomColorOutput = nullptr; |
226 | |
227 | bool fSetupFragPosition = false; |
228 | bool fHasSecondaryOutput = false; |
229 | bool fHasModifiedSampleMask = false; |
230 | bool fForceHighPrecision = false; |
231 | |
232 | friend class GrGLSLProgramBuilder; |
233 | friend class GrGLProgramBuilder; |
234 | }; |
235 | |
236 | #endif |
237 | |