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
16class GrRenderTarget;
17class GrGLSLVarying;
18
19/*
20 * This base class encapsulates the common functionality which all processors use to build fragment
21 * shaders.
22 */
23class GrGLSLFragmentBuilder : public GrGLSLShaderBuilder {
24public:
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
39private:
40 typedef GrGLSLShaderBuilder INHERITED;
41};
42
43/*
44 * This class is used by fragment processors to build their fragment code.
45 */
46class GrGLSLFPFragmentBuilder : virtual public GrGLSLFragmentBuilder {
47public:
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
111private:
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
121GR_MAKE_BITFIELD_CLASS_OPS(GrGLSLFPFragmentBuilder::ScopeFlags);
122
123/*
124 * This class is used by Xfer processors to build their fragment code.
125 */
126class GrGLSLXPFragmentBuilder : virtual public GrGLSLFragmentBuilder {
127public:
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 */
147class GrGLSLFragmentShaderBuilder : public GrGLSLFPFragmentBuilder, public GrGLSLXPFragmentBuilder {
148public:
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
173private:
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