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 "GrBlend.h"
12#include "GrGLSLShaderBuilder.h"
13#include "GrProcessor.h"
14
15class GrRenderTarget;
16class GrGLSLVarying;
17
18/*
19 * This base class encapsulates the common functionality which all processors use to build fragment
20 * shaders.
21 */
22class GrGLSLFragmentBuilder : public GrGLSLShaderBuilder {
23public:
24    GrGLSLFragmentBuilder(GrGLSLProgramBuilder* program) : INHERITED(program) {}
25    virtual ~GrGLSLFragmentBuilder() {}
26
27    /**
28     * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
29     * if code is added that uses one of these features without calling enableFeature()
30     */
31    enum GLSLFeature {
32        kMultisampleInterpolation_GLSLFeature
33    };
34
35    /**
36     * If the feature is supported then true is returned and any necessary #extension declarations
37     * are added to the shaders. If the feature is not supported then false will be returned.
38     */
39    virtual bool enableFeature(GLSLFeature) = 0;
40
41    /**
42     * This returns a variable name to access the 2D, perspective correct version of the coords in
43     * the fragment shader. The passed in coordinates must either be of type kVec2f or kVec3f. If
44     * the coordinates are 3-dimensional, it a perspective divide into is emitted into the
45     * fragment shader (xy / z) to convert them to 2D.
46     */
47    virtual SkString ensureCoords2D(const GrShaderVar&) = 0;
48
49    // TODO: remove this method.
50    void declAppendf(const char* fmt, ...);
51
52private:
53    typedef GrGLSLShaderBuilder INHERITED;
54};
55
56/*
57 * This class is used by fragment processors to build their fragment code.
58 */
59class GrGLSLFPFragmentBuilder : virtual public GrGLSLFragmentBuilder {
60public:
61    /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */
62    GrGLSLFPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) {}
63
64    enum Coordinates {
65        kSkiaDevice_Coordinates,
66        kGLSLWindow_Coordinates,
67
68        kLast_Coordinates = kGLSLWindow_Coordinates
69    };
70
71    /**
72     * Appends the offset from the center of the pixel to a specified sample.
73     *
74     * @param sampleIdx      GLSL expression of the sample index.
75     * @param Coordinates    Coordinate space in which to emit the offset.
76     *
77     * A processor must call setWillUseSampleLocations in its constructor before using this method.
78     */
79    virtual void appendOffsetToSample(const char* sampleIdx, Coordinates) = 0;
80
81    /**
82     * Subtracts sample coverage from the fragment. Any sample whose corresponding bit is not found
83     * in the mask will not be written out to the framebuffer.
84     *
85     * @param mask      int that contains the sample mask. Bit N corresponds to the Nth sample.
86     * @param invert    perform a bit-wise NOT on the provided mask before applying it?
87     *
88     * Requires GLSL support for sample variables.
89     */
90    virtual void maskSampleCoverage(const char* mask, bool invert = false) = 0;
91
92    /**
93     * Overrides the default precision for the entire fragment program. Processors that require
94     * high precision input (eg from incoming texture samples) may use this. For calculations that
95     * are limited to a single processor's code, it is better to annotate individual declarations.
96     */
97    virtual void elevateDefaultPrecision(GrSLPrecision) = 0;
98
99    /**
100     * Fragment procs with child procs should call these functions before/after calling emitCode
101     * on a child proc.
102     */
103    virtual void onBeforeChildProcEmitCode() = 0;
104    virtual void onAfterChildProcEmitCode() = 0;
105
106    virtual const SkString& getMangleString() const = 0;
107};
108
109/*
110 * This class is used by primitive processors to build their fragment code.
111 */
112class GrGLSLPPFragmentBuilder : public GrGLSLFPFragmentBuilder {
113public:
114    /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */
115    GrGLSLPPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) {}
116
117    /**
118     * Overrides the fragment's sample coverage. The provided mask determines which samples will now
119     * be written out to the framebuffer. Note that this mask can be reduced by a future call to
120     * maskSampleCoverage.
121     *
122     * If a primitive processor uses this method, it must guarantee that every codepath through the
123     * shader overrides the sample mask at some point.
124     *
125     * @param mask    int that contains the new coverage mask. Bit N corresponds to the Nth sample.
126     *
127     * Requires NV_sample_mask_override_coverage.
128     */
129    virtual void overrideSampleCoverage(const char* mask) = 0;
130};
131
132/*
133 * This class is used by Xfer processors to build their fragment code.
134 */
135class GrGLSLXPFragmentBuilder : virtual public GrGLSLFragmentBuilder {
136public:
137    /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */
138    GrGLSLXPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) {}
139
140    virtual bool hasCustomColorOutput() const = 0;
141    virtual bool hasSecondaryOutput() const = 0;
142
143    /** Returns the variable name that holds the color of the destination pixel. This may be nullptr
144     * if no effect advertised that it will read the destination. */
145    virtual const char* dstColor() = 0;
146
147    /** Adds any necessary layout qualifiers in order to legalize the supplied blend equation with
148        this shader. It is only legal to call this method with an advanced blend equation, and only
149        if these equations are supported. */
150    virtual void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) = 0;
151};
152
153/*
154 * This class implements the various fragment builder interfaces.
155 */
156class GrGLSLFragmentShaderBuilder : public GrGLSLPPFragmentBuilder, public GrGLSLXPFragmentBuilder {
157public:
158   /** Returns a nonzero key for a surface's origin. This should only be called if a processor will
159       use the fragment position and/or sample locations. */
160    static uint8_t KeyForSurfaceOrigin(GrSurfaceOrigin);
161
162    GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program);
163
164    // Shared GrGLSLFragmentBuilder interface.
165    bool enableFeature(GLSLFeature) override;
166    virtual SkString ensureCoords2D(const GrShaderVar&) override;
167
168    // GrGLSLFPFragmentBuilder interface.
169    void appendOffsetToSample(const char* sampleIdx, Coordinates) override;
170    void maskSampleCoverage(const char* mask, bool invert = false) override;
171    void overrideSampleCoverage(const char* mask) override;
172    void elevateDefaultPrecision(GrSLPrecision) override;
173    const SkString& getMangleString() const override { return fMangleString; }
174    void onBeforeChildProcEmitCode() override;
175    void onAfterChildProcEmitCode() override;
176
177    // GrGLSLXPFragmentBuilder interface.
178    bool hasCustomColorOutput() const override { return fHasCustomColorOutput; }
179    bool hasSecondaryOutput() const override { return fHasSecondaryOutput; }
180    const char* dstColor() override;
181    void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override;
182
183private:
184    // Private public interface, used by GrGLProgramBuilder to build a fragment shader
185    void enableCustomOutput();
186    void enableSecondaryOutput();
187    const char* getPrimaryColorOutputName() const;
188    const char* getSecondaryColorOutputName() const;
189
190#ifdef SK_DEBUG
191    // As GLSLProcessors emit code, there are some conditions we need to verify.  We use the below
192    // state to track this.  The reset call is called per processor emitted.
193    GrProcessor::RequiredFeatures usedProcessorFeatures() const { return fUsedProcessorFeatures; }
194    bool hasReadDstColor() const { return fHasReadDstColor; }
195    void resetVerification() {
196        fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures;
197        fHasReadDstColor = false;
198    }
199#endif
200
201    static const char* DeclaredColorOutputName() { return "sk_FragColor"; }
202    static const char* DeclaredSecondaryColorOutputName() { return "fsSecondaryColorOut"; }
203
204    GrSurfaceOrigin getSurfaceOrigin() const;
205
206    void onFinalize() override;
207    void defineSampleOffsetArray(const char* name, const SkMatrix&);
208
209    static const char* kDstColorName;
210
211    /*
212     * State that tracks which child proc in the proc tree is currently emitting code.  This is
213     * used to update the fMangleString, which is used to mangle the names of uniforms and functions
214     * emitted by the proc.  fSubstageIndices is a stack: its count indicates how many levels deep
215     * we are in the tree, and its second-to-last value is the index of the child proc at that
216     * level which is currently emitting code. For example, if fSubstageIndices = [3, 1, 2, 0], that
217     * means we're currently emitting code for the base proc's 3rd child's 1st child's 2nd child.
218     */
219    SkTArray<int> fSubstageIndices;
220
221    /*
222     * The mangle string is used to mangle the names of uniforms/functions emitted by the child
223     * procs so no duplicate uniforms/functions appear in the generated shader program. The mangle
224     * string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0],
225     * then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will
226     * have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's
227     * 1st child's 2nd child".
228     */
229    SkString fMangleString;
230
231    bool          fSetupFragPosition;
232    bool          fHasCustomColorOutput;
233    int           fCustomColorOutputIndex;
234    bool          fHasSecondaryOutput;
235    uint8_t       fUsedSampleOffsetArrays;
236    bool          fHasInitializedSampleMask;
237    GrSLPrecision fDefaultPrecision;
238
239#ifdef SK_DEBUG
240    // some state to verify shaders and effects are consistent, this is reset between effects by
241    // the program creator
242    GrProcessor::RequiredFeatures fUsedProcessorFeatures;
243    bool fHasReadDstColor;
244#endif
245
246    friend class GrGLSLProgramBuilder;
247    friend class GrGLProgramBuilder;
248};
249
250#endif
251