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 15 class GrRenderTarget; 16 class GrGLSLVarying; 17 18 /* 19 * This base class encapsulates the common functionality which all processors use to build fragment 20 * shaders. 21 */ 22 class GrGLSLFragmentBuilder : public GrGLSLShaderBuilder { 23 public: GrGLSLFragmentBuilder(GrGLSLProgramBuilder * program)24 GrGLSLFragmentBuilder(GrGLSLProgramBuilder* program) : INHERITED(program) {} ~GrGLSLFragmentBuilder()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 52 private: 53 typedef GrGLSLShaderBuilder INHERITED; 54 }; 55 56 /* 57 * This class is used by fragment processors to build their fragment code. 58 */ 59 class GrGLSLFPFragmentBuilder : virtual public GrGLSLFragmentBuilder { 60 public: 61 /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */ GrGLSLFPFragmentBuilder()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 */ 112 class GrGLSLPPFragmentBuilder : public GrGLSLFPFragmentBuilder { 113 public: 114 /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */ GrGLSLPPFragmentBuilder()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 */ 135 class GrGLSLXPFragmentBuilder : virtual public GrGLSLFragmentBuilder { 136 public: 137 /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */ GrGLSLXPFragmentBuilder()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 */ 156 class GrGLSLFragmentShaderBuilder : public GrGLSLPPFragmentBuilder, public GrGLSLXPFragmentBuilder { 157 public: 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; getMangleString()173 const SkString& getMangleString() const override { return fMangleString; } 174 void onBeforeChildProcEmitCode() override; 175 void onAfterChildProcEmitCode() override; 176 177 // GrGLSLXPFragmentBuilder interface. hasCustomColorOutput()178 bool hasCustomColorOutput() const override { return fHasCustomColorOutput; } hasSecondaryOutput()179 bool hasSecondaryOutput() const override { return fHasSecondaryOutput; } 180 const char* dstColor() override; 181 void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override; 182 183 private: 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. usedProcessorFeatures()193 GrProcessor::RequiredFeatures usedProcessorFeatures() const { return fUsedProcessorFeatures; } hasReadDstColor()194 bool hasReadDstColor() const { return fHasReadDstColor; } resetVerification()195 void resetVerification() { 196 fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures; 197 fHasReadDstColor = false; 198 } 199 #endif 200 DeclaredColorOutputName()201 static const char* DeclaredColorOutputName() { return "sk_FragColor"; } DeclaredSecondaryColorOutputName()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