blob: a9493b81dc5c6b9068221e233ac732d8be34b683 [file] [log] [blame]
joshualitt30ba4362014-08-21 20:18:45 -07001/*
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
egdaniel2d721d32015-11-11 13:06:05 -08008#include "GrGLSLFragmentShaderBuilder.h"
egdaniel574a4c12015-11-02 06:22:44 -08009#include "GrRenderTarget.h"
cdalton28f45b92016-03-07 13:58:26 -080010#include "GrRenderTargetPriv.h"
ethannicholas22793252016-01-30 09:59:10 -080011#include "gl/GrGLGpu.h"
egdanielcb7ba1e2015-10-26 08:38:25 -070012#include "glsl/GrGLSL.h"
jvanverthcba99b82015-06-24 06:59:57 -070013#include "glsl/GrGLSLCaps.h"
egdaniel8dcdedc2015-11-11 06:27:20 -080014#include "glsl/GrGLSLProgramBuilder.h"
egdaniel7ea439b2015-12-03 09:20:44 -080015#include "glsl/GrGLSLUniformHandler.h"
egdaniel0eafe792015-11-20 14:01:22 -080016#include "glsl/GrGLSLVarying.h"
joshualitt47bb3822014-10-07 16:43:25 -070017
egdaniel138c2632016-08-17 10:59:00 -070018const char* GrGLSLFragmentShaderBuilder::kDstColorName = "_dstColor";
joshualitt30ba4362014-08-21 20:18:45 -070019
cdalton28f45b92016-03-07 13:58:26 -080020static const char* sample_offset_array_name(GrGLSLFPFragmentBuilder::Coordinates coords) {
21 static const char* kArrayNames[] = {
22 "deviceSpaceSampleOffsets",
23 "windowSpaceSampleOffsets"
24 };
25 return kArrayNames[coords];
26
27 GR_STATIC_ASSERT(0 == GrGLSLFPFragmentBuilder::kSkiaDevice_Coordinates);
28 GR_STATIC_ASSERT(1 == GrGLSLFPFragmentBuilder::kGLSLWindow_Coordinates);
29 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kArrayNames) == GrGLSLFPFragmentBuilder::kLast_Coordinates + 1);
30}
31
cdalton8917d622015-05-06 13:40:21 -070032static const char* specific_layout_qualifier_name(GrBlendEquation equation) {
33 SkASSERT(GrBlendEquationIsAdvanced(equation));
34
35 static const char* kLayoutQualifierNames[] = {
36 "blend_support_screen",
37 "blend_support_overlay",
38 "blend_support_darken",
39 "blend_support_lighten",
40 "blend_support_colordodge",
41 "blend_support_colorburn",
42 "blend_support_hardlight",
43 "blend_support_softlight",
44 "blend_support_difference",
45 "blend_support_exclusion",
46 "blend_support_multiply",
47 "blend_support_hsl_hue",
48 "blend_support_hsl_saturation",
49 "blend_support_hsl_color",
50 "blend_support_hsl_luminosity"
51 };
52 return kLayoutQualifierNames[equation - kFirstAdvancedGrBlendEquation];
53
54 GR_STATIC_ASSERT(0 == kScreen_GrBlendEquation - kFirstAdvancedGrBlendEquation);
55 GR_STATIC_ASSERT(1 == kOverlay_GrBlendEquation - kFirstAdvancedGrBlendEquation);
56 GR_STATIC_ASSERT(2 == kDarken_GrBlendEquation - kFirstAdvancedGrBlendEquation);
57 GR_STATIC_ASSERT(3 == kLighten_GrBlendEquation - kFirstAdvancedGrBlendEquation);
58 GR_STATIC_ASSERT(4 == kColorDodge_GrBlendEquation - kFirstAdvancedGrBlendEquation);
59 GR_STATIC_ASSERT(5 == kColorBurn_GrBlendEquation - kFirstAdvancedGrBlendEquation);
60 GR_STATIC_ASSERT(6 == kHardLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
61 GR_STATIC_ASSERT(7 == kSoftLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
62 GR_STATIC_ASSERT(8 == kDifference_GrBlendEquation - kFirstAdvancedGrBlendEquation);
63 GR_STATIC_ASSERT(9 == kExclusion_GrBlendEquation - kFirstAdvancedGrBlendEquation);
64 GR_STATIC_ASSERT(10 == kMultiply_GrBlendEquation - kFirstAdvancedGrBlendEquation);
65 GR_STATIC_ASSERT(11 == kHSLHue_GrBlendEquation - kFirstAdvancedGrBlendEquation);
66 GR_STATIC_ASSERT(12 == kHSLSaturation_GrBlendEquation - kFirstAdvancedGrBlendEquation);
67 GR_STATIC_ASSERT(13 == kHSLColor_GrBlendEquation - kFirstAdvancedGrBlendEquation);
68 GR_STATIC_ASSERT(14 == kHSLLuminosity_GrBlendEquation - kFirstAdvancedGrBlendEquation);
69 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kLayoutQualifierNames) ==
bsalomonf7cc8772015-05-11 11:21:14 -070070 kGrBlendEquationCnt - kFirstAdvancedGrBlendEquation);
cdalton8917d622015-05-06 13:40:21 -070071}
72
cdalton28f45b92016-03-07 13:58:26 -080073uint8_t GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(GrSurfaceOrigin origin) {
74 SkASSERT(kTopLeft_GrSurfaceOrigin == origin || kBottomLeft_GrSurfaceOrigin == origin);
75 return origin;
76
77 GR_STATIC_ASSERT(1 == kTopLeft_GrSurfaceOrigin);
78 GR_STATIC_ASSERT(2 == kBottomLeft_GrSurfaceOrigin);
joshualitt30ba4362014-08-21 20:18:45 -070079}
80
cdalton28f45b92016-03-07 13:58:26 -080081GrGLSLFragmentShaderBuilder::GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program)
cdalton85285412016-02-18 12:37:07 -080082 : GrGLSLFragmentBuilder(program)
joshualitt30ba4362014-08-21 20:18:45 -070083 , fSetupFragPosition(false)
cdalton85285412016-02-18 12:37:07 -080084 , fHasCustomColorOutput(false)
joshualittb4384b92014-10-21 12:53:15 -070085 , fCustomColorOutputIndex(-1)
cdalton85285412016-02-18 12:37:07 -080086 , fHasSecondaryOutput(false)
cdalton28f45b92016-03-07 13:58:26 -080087 , fUsedSampleOffsetArrays(0)
cdalton87332102016-02-26 12:22:02 -080088 , fHasInitializedSampleMask(false) {
cdalton85285412016-02-18 12:37:07 -080089 fSubstageIndices.push_back(0);
cdalton87332102016-02-26 12:22:02 -080090#ifdef SK_DEBUG
91 fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures;
92 fHasReadDstColor = false;
93#endif
94}
95
egdaniel2d721d32015-11-11 13:06:05 -080096bool GrGLSLFragmentShaderBuilder::enableFeature(GLSLFeature feature) {
cdalton4a98cdb2016-03-01 12:12:20 -080097 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps();
joshualitt30ba4362014-08-21 20:18:45 -070098 switch (feature) {
cdalton4a98cdb2016-03-01 12:12:20 -080099 case kPixelLocalStorage_GLSLFeature:
100 if (glslCaps.pixelLocalStorageSize() <= 0) {
ethannicholas22793252016-01-30 09:59:10 -0800101 return false;
102 }
103 this->addFeature(1 << kPixelLocalStorage_GLSLFeature,
104 "GL_EXT_shader_pixel_local_storage");
105 return true;
cdalton4a98cdb2016-03-01 12:12:20 -0800106 case kMultisampleInterpolation_GLSLFeature:
107 if (!glslCaps.multisampleInterpolationSupport()) {
108 return false;
109 }
110 if (const char* extension = glslCaps.multisampleInterpolationExtensionString()) {
111 this->addFeature(1 << kMultisampleInterpolation_GLSLFeature, extension);
112 }
113 return true;
joshualitt30ba4362014-08-21 20:18:45 -0700114 default:
115 SkFAIL("Unexpected GLSLFeature requested.");
116 return false;
117 }
118}
119
bsalomon1a1aa932016-09-12 09:30:36 -0700120SkString GrGLSLFragmentShaderBuilder::ensureCoords2D(const GrShaderVar& coords) {
121 if (kVec3f_GrSLType != coords.getType()) {
122 SkASSERT(kVec2f_GrSLType == coords.getType());
123 return coords.getName();
joshualitt30ba4362014-08-21 20:18:45 -0700124 }
125
bsalomon1a1aa932016-09-12 09:30:36 -0700126 SkString coords2D;
127 coords2D.printf("%s_ensure2D", coords.c_str());
128 this->codeAppendf("\tvec2 %s = %s.xy / %s.z;", coords2D.c_str(), coords.c_str(),
129 coords.c_str());
joshualitt30ba4362014-08-21 20:18:45 -0700130 return coords2D;
131}
132
egdaniel2d721d32015-11-11 13:06:05 -0800133const char* GrGLSLFragmentShaderBuilder::fragmentPosition() {
cdalton87332102016-02-26 12:22:02 -0800134 SkDEBUGCODE(fUsedProcessorFeatures |= GrProcessor::kFragmentPosition_RequiredFeature;)
joshualitt30ba4362014-08-21 20:18:45 -0700135
egdaniel8dcdedc2015-11-11 06:27:20 -0800136 const GrGLSLCaps* glslCaps = fProgramBuilder->glslCaps();
joshualitt30ba4362014-08-21 20:18:45 -0700137 // We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers
138 // to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the
139 // declaration varies in earlier GLSL specs. So it is simpler to omit it.
cdalton28f45b92016-03-07 13:58:26 -0800140 if (kTopLeft_GrSurfaceOrigin == this->getSurfaceOrigin()) {
joshualitt30ba4362014-08-21 20:18:45 -0700141 fSetupFragPosition = true;
142 return "gl_FragCoord";
egdaniel8dcdedc2015-11-11 06:27:20 -0800143 } else if (const char* extension = glslCaps->fragCoordConventionsExtensionString()) {
joshualitt30ba4362014-08-21 20:18:45 -0700144 if (!fSetupFragPosition) {
egdaniel8dcdedc2015-11-11 06:27:20 -0800145 if (glslCaps->generation() < k150_GrGLSLGeneration) {
joshualitt30ba4362014-08-21 20:18:45 -0700146 this->addFeature(1 << kFragCoordConventions_GLSLPrivateFeature,
egdaniel8dcdedc2015-11-11 06:27:20 -0800147 extension);
joshualitt30ba4362014-08-21 20:18:45 -0700148 }
149 fInputs.push_back().set(kVec4f_GrSLType,
egdaniel0d3f0612015-10-21 10:45:48 -0700150 GrGLSLShaderVar::kIn_TypeModifier,
joshualitt30ba4362014-08-21 20:18:45 -0700151 "gl_FragCoord",
bsalomonc0bd6482014-12-09 10:04:14 -0800152 kDefault_GrSLPrecision,
egdanielae474182016-01-21 11:19:52 -0800153 "origin_upper_left");
joshualitt30ba4362014-08-21 20:18:45 -0700154 fSetupFragPosition = true;
155 }
156 return "gl_FragCoord";
157 } else {
robertphillips18c58c72015-07-21 12:06:52 -0700158 static const char* kTempName = "tmpXYFragCoord";
joshualitt30ba4362014-08-21 20:18:45 -0700159 static const char* kCoordName = "fragCoordYDown";
160 if (!fSetupFragPosition) {
joshualitt30ba4362014-08-21 20:18:45 -0700161 const char* rtHeightName;
162
egdaniel7ea439b2015-12-03 09:20:44 -0800163 fProgramBuilder->addRTHeightUniform("RTHeight", &rtHeightName);
joshualitt30ba4362014-08-21 20:18:45 -0700164
robertphillips18c58c72015-07-21 12:06:52 -0700165 // The Adreno compiler seems to be very touchy about access to "gl_FragCoord".
166 // Accessing glFragCoord.zw can cause a program to fail to link. Additionally,
167 // depending on the surrounding code, accessing .xy with a uniform involved can
halcanary9d524f22016-03-29 09:03:52 -0700168 // do the same thing. Copying gl_FragCoord.xy into a temp vec2 beforehand
robertphillips18c58c72015-07-21 12:06:52 -0700169 // (and only accessing .xy) seems to "fix" things.
ethannicholas1cbb5ea2015-12-14 11:37:55 -0800170 const char* precision = glslCaps->usesPrecisionModifiers() ? "highp " : "";
171 this->codePrependf("\t%svec4 %s = vec4(%s.x, %s - %s.y, 1.0, 1.0);\n",
172 precision, kCoordName, kTempName, rtHeightName, kTempName);
173 this->codePrependf("%svec2 %s = gl_FragCoord.xy;", precision, kTempName);
joshualitt30ba4362014-08-21 20:18:45 -0700174 fSetupFragPosition = true;
175 }
176 SkASSERT(fProgramBuilder->fUniformHandles.fRTHeightUni.isValid());
177 return kCoordName;
178 }
179}
180
dvonbeck9b03e7b2016-08-01 11:01:56 -0700181const char* GrGLSLFragmentShaderBuilder::distanceVectorName() const {
182 return "fsDistanceVector";
183}
184
cdalton28f45b92016-03-07 13:58:26 -0800185void GrGLSLFragmentShaderBuilder::appendOffsetToSample(const char* sampleIdx, Coordinates coords) {
186 SkASSERT(fProgramBuilder->header().fSamplePatternKey);
187 SkDEBUGCODE(fUsedProcessorFeatures |= GrProcessor::kSampleLocations_RequiredFeature);
188 if (kTopLeft_GrSurfaceOrigin == this->getSurfaceOrigin()) {
189 // With a top left origin, device and window space are equal, so we only use device coords.
190 coords = kSkiaDevice_Coordinates;
191 }
192 this->codeAppendf("%s[%s]", sample_offset_array_name(coords), sampleIdx);
193 fUsedSampleOffsetArrays |= (1 << coords);
194}
195
cdalton33ad7012016-02-22 07:55:44 -0800196void GrGLSLFragmentShaderBuilder::maskSampleCoverage(const char* mask, bool invert) {
197 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps();
198 if (!glslCaps.sampleVariablesSupport()) {
199 SkDEBUGFAIL("Attempted to mask sample coverage without support.");
200 return;
201 }
202 if (const char* extension = glslCaps.sampleVariablesExtensionString()) {
203 this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension);
204 }
205 if (!fHasInitializedSampleMask) {
206 this->codePrependf("gl_SampleMask[0] = -1;");
207 fHasInitializedSampleMask = true;
208 }
209 if (invert) {
210 this->codeAppendf("gl_SampleMask[0] &= ~(%s);", mask);
211 } else {
212 this->codeAppendf("gl_SampleMask[0] &= %s;", mask);
213 }
214}
215
216void GrGLSLFragmentShaderBuilder::overrideSampleCoverage(const char* mask) {
217 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps();
218 if (!glslCaps.sampleMaskOverrideCoverageSupport()) {
219 SkDEBUGFAIL("Attempted to override sample coverage without support.");
220 return;
221 }
222 SkASSERT(glslCaps.sampleVariablesSupport());
223 if (const char* extension = glslCaps.sampleVariablesExtensionString()) {
224 this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension);
225 }
226 if (this->addFeature(1 << kSampleMaskOverrideCoverage_GLSLPrivateFeature,
227 "GL_NV_sample_mask_override_coverage")) {
228 // Redeclare gl_SampleMask with layout(override_coverage) if we haven't already.
229 fOutputs.push_back().set(kInt_GrSLType, GrShaderVar::kOut_TypeModifier,
230 "gl_SampleMask", 1, kHigh_GrSLPrecision,
231 "override_coverage");
232 }
233 this->codeAppendf("gl_SampleMask[0] = %s;", mask);
234 fHasInitializedSampleMask = true;
235}
236
egdaniel2d721d32015-11-11 13:06:05 -0800237const char* GrGLSLFragmentShaderBuilder::dstColor() {
cdalton87332102016-02-26 12:22:02 -0800238 SkDEBUGCODE(fHasReadDstColor = true;)
joshualitt47bb3822014-10-07 16:43:25 -0700239
ethannicholas22793252016-01-30 09:59:10 -0800240 const char* override = fProgramBuilder->primitiveProcessor().getDestColorOverride();
241 if (override != nullptr) {
242 return override;
243 }
244
egdaniel472d44e2015-10-22 08:20:00 -0700245 const GrGLSLCaps* glslCaps = fProgramBuilder->glslCaps();
246 if (glslCaps->fbFetchSupport()) {
cdaltonc08f1962016-02-12 12:14:06 -0800247 this->addFeature(1 << kFramebufferFetch_GLSLPrivateFeature,
egdaniel472d44e2015-10-22 08:20:00 -0700248 glslCaps->fbFetchExtensionString());
joshualittb4384b92014-10-21 12:53:15 -0700249
joshualitt3c1096f2015-01-13 13:13:59 -0800250 // Some versions of this extension string require declaring custom color output on ES 3.0+
egdaniel472d44e2015-10-22 08:20:00 -0700251 const char* fbFetchColorName = glslCaps->fbFetchColorName();
252 if (glslCaps->fbFetchNeedsCustomOutput()) {
joshualittb4384b92014-10-21 12:53:15 -0700253 this->enableCustomOutput();
254 fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier);
egdaniel8dcdedc2015-11-11 06:27:20 -0800255 fbFetchColorName = DeclaredColorOutputName();
egdaniel138c2632016-08-17 10:59:00 -0700256 // Set the dstColor to an intermediate variable so we don't override it with the output
257 this->codeAppendf("vec4 %s = %s;", kDstColorName, fbFetchColorName);
egdanielbd4121a2016-08-17 12:55:30 -0700258 } else {
259 return fbFetchColorName;
joshualittb4384b92014-10-21 12:53:15 -0700260 }
halcanary9d524f22016-03-29 09:03:52 -0700261 }
egdaniel138c2632016-08-17 10:59:00 -0700262 return kDstColorName;
joshualitt47bb3822014-10-07 16:43:25 -0700263}
264
egdaniel2d721d32015-11-11 13:06:05 -0800265void GrGLSLFragmentShaderBuilder::enableAdvancedBlendEquationIfNeeded(GrBlendEquation equation) {
cdalton8917d622015-05-06 13:40:21 -0700266 SkASSERT(GrBlendEquationIsAdvanced(equation));
267
egdaniel472d44e2015-10-22 08:20:00 -0700268 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps();
cdalton8917d622015-05-06 13:40:21 -0700269 if (!caps.mustEnableAdvBlendEqs()) {
270 return;
271 }
272
273 this->addFeature(1 << kBlendEquationAdvanced_GLSLPrivateFeature,
274 "GL_KHR_blend_equation_advanced");
275 if (caps.mustEnableSpecificAdvBlendEqs()) {
276 this->addLayoutQualifier(specific_layout_qualifier_name(equation), kOut_InterfaceQualifier);
277 } else {
278 this->addLayoutQualifier("blend_support_all_equations", kOut_InterfaceQualifier);
279 }
280}
281
egdaniel2d721d32015-11-11 13:06:05 -0800282void GrGLSLFragmentShaderBuilder::enableCustomOutput() {
joshualittb4384b92014-10-21 12:53:15 -0700283 if (!fHasCustomColorOutput) {
284 fHasCustomColorOutput = true;
285 fCustomColorOutputIndex = fOutputs.count();
ethannicholas5961bc92016-10-12 06:39:56 -0700286 fOutputs.push_back().set(kVec4f_GrSLType,
287 GrGLSLShaderVar::kOut_TypeModifier,
288 DeclaredColorOutputName());
289 fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back());
joshualittb4384b92014-10-21 12:53:15 -0700290 }
joshualitt47bb3822014-10-07 16:43:25 -0700291}
292
egdaniel2d721d32015-11-11 13:06:05 -0800293void GrGLSLFragmentShaderBuilder::enableSecondaryOutput() {
joshualitt47bb3822014-10-07 16:43:25 -0700294 SkASSERT(!fHasSecondaryOutput);
295 fHasSecondaryOutput = true;
egdaniel8dcdedc2015-11-11 06:27:20 -0800296 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps();
297 if (const char* extension = caps.secondaryOutputExtensionString()) {
298 this->addFeature(1 << kBlendFuncExtended_GLSLPrivateFeature, extension);
kkinnunend94708e2015-07-30 22:47:04 -0700299 }
300
301 // If the primary output is declared, we must declare also the secondary output
302 // and vice versa, since it is not allowed to use a built-in gl_FragColor and a custom
303 // output. The condition also co-incides with the condition in whici GLES SL 2.0
304 // requires the built-in gl_SecondaryFragColorEXT, where as 3.0 requires a custom output.
kkinnunend94708e2015-07-30 22:47:04 -0700305 if (caps.mustDeclareFragmentShaderOutput()) {
egdaniel0d3f0612015-10-21 10:45:48 -0700306 fOutputs.push_back().set(kVec4f_GrSLType, GrGLSLShaderVar::kOut_TypeModifier,
egdaniel8dcdedc2015-11-11 06:27:20 -0800307 DeclaredSecondaryColorOutputName());
egdanielb80ec8b2016-02-09 09:54:43 -0800308 fProgramBuilder->finalizeFragmentSecondaryColor(fOutputs.back());
kkinnunend94708e2015-07-30 22:47:04 -0700309 }
joshualitt47bb3822014-10-07 16:43:25 -0700310}
311
egdaniel2d721d32015-11-11 13:06:05 -0800312const char* GrGLSLFragmentShaderBuilder::getPrimaryColorOutputName() const {
ethannicholas5961bc92016-10-12 06:39:56 -0700313 return fHasCustomColorOutput ? DeclaredColorOutputName() : "sk_FragColor";
joshualitt47bb3822014-10-07 16:43:25 -0700314}
315
ethannicholas22793252016-01-30 09:59:10 -0800316void GrGLSLFragmentBuilder::declAppendf(const char* fmt, ...) {
317 va_list argp;
318 va_start(argp, fmt);
319 inputs().appendVAList(fmt, argp);
halcanary9d524f22016-03-29 09:03:52 -0700320 va_end(argp);
ethannicholas22793252016-01-30 09:59:10 -0800321}
322
egdaniel2d721d32015-11-11 13:06:05 -0800323const char* GrGLSLFragmentShaderBuilder::getSecondaryColorOutputName() const {
egdaniel8dcdedc2015-11-11 06:27:20 -0800324 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps();
325 return caps.mustDeclareFragmentShaderOutput() ? DeclaredSecondaryColorOutputName()
kkinnunend94708e2015-07-30 22:47:04 -0700326 : "gl_SecondaryFragColorEXT";
joshualitt47bb3822014-10-07 16:43:25 -0700327}
328
cdalton28f45b92016-03-07 13:58:26 -0800329GrSurfaceOrigin GrGLSLFragmentShaderBuilder::getSurfaceOrigin() const {
330 SkASSERT(fProgramBuilder->header().fSurfaceOriginKey);
331 return static_cast<GrSurfaceOrigin>(fProgramBuilder->header().fSurfaceOriginKey);
332
333 GR_STATIC_ASSERT(1 == kTopLeft_GrSurfaceOrigin);
334 GR_STATIC_ASSERT(2 == kBottomLeft_GrSurfaceOrigin);
335}
336
egdaniel2d721d32015-11-11 13:06:05 -0800337void GrGLSLFragmentShaderBuilder::onFinalize() {
egdaniel0eafe792015-11-20 14:01:22 -0800338 fProgramBuilder->varyingHandler()->getFragDecls(&this->inputs(), &this->outputs());
egdanielcb7ba1e2015-10-26 08:38:25 -0700339 GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision,
340 *fProgramBuilder->glslCaps(),
341 &this->precisionQualifier());
cdalton28f45b92016-03-07 13:58:26 -0800342 if (fUsedSampleOffsetArrays & (1 << kSkiaDevice_Coordinates)) {
343 this->defineSampleOffsetArray(sample_offset_array_name(kSkiaDevice_Coordinates),
344 SkMatrix::MakeTrans(-0.5f, -0.5f));
345 }
346 if (fUsedSampleOffsetArrays & (1 << kGLSLWindow_Coordinates)) {
347 // With a top left origin, device and window space are equal, so we only use device coords.
348 SkASSERT(kBottomLeft_GrSurfaceOrigin == this->getSurfaceOrigin());
349 SkMatrix m;
350 m.setScale(1, -1);
351 m.preTranslate(-0.5f, -0.5f);
352 this->defineSampleOffsetArray(sample_offset_array_name(kGLSLWindow_Coordinates), m);
353 }
354}
355
356void GrGLSLFragmentShaderBuilder::defineSampleOffsetArray(const char* name, const SkMatrix& m) {
357 SkASSERT(fProgramBuilder->caps()->sampleLocationsSupport());
358 const GrPipeline& pipeline = fProgramBuilder->pipeline();
359 const GrRenderTargetPriv& rtp = pipeline.getRenderTarget()->renderTargetPriv();
csmartdaltonc633abb2016-11-01 08:55:55 -0700360 const GrGpu::MultisampleSpecs& specs = rtp.getMultisampleSpecs(pipeline);
cdalton28f45b92016-03-07 13:58:26 -0800361 SkSTArray<16, SkPoint, true> offsets;
362 offsets.push_back_n(specs.fEffectiveSampleCnt);
csmartdalton0d28e572016-07-06 09:59:43 -0700363 m.mapPoints(offsets.begin(), specs.fSampleLocations, specs.fEffectiveSampleCnt);
cdalton28f45b92016-03-07 13:58:26 -0800364 this->definitions().append("const ");
365 if (fProgramBuilder->glslCaps()->usesPrecisionModifiers()) {
366 this->definitions().append("highp ");
367 }
368 this->definitions().appendf("vec2 %s[] = vec2[](", name);
369 for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) {
370 this->definitions().appendf("vec2(%f, %f)", offsets[i].x(), offsets[i].y());
371 this->definitions().append(i + 1 != specs.fEffectiveSampleCnt ? ", " : ");\n");
372 }
joshualitt30ba4362014-08-21 20:18:45 -0700373}
374
cdalton85285412016-02-18 12:37:07 -0800375void GrGLSLFragmentShaderBuilder::onBeforeChildProcEmitCode() {
wangyix54a6b1a2015-09-08 08:41:51 -0700376 SkASSERT(fSubstageIndices.count() >= 1);
wangyix7ef45a12015-08-13 06:51:35 -0700377 fSubstageIndices.push_back(0);
wangyix54a6b1a2015-09-08 08:41:51 -0700378 // second-to-last value in the fSubstageIndices stack is the index of the child proc
379 // at that level which is currently emitting code.
380 fMangleString.appendf("_c%d", fSubstageIndices[fSubstageIndices.count() - 2]);
wangyix7ef45a12015-08-13 06:51:35 -0700381}
382
cdalton85285412016-02-18 12:37:07 -0800383void GrGLSLFragmentShaderBuilder::onAfterChildProcEmitCode() {
wangyix54a6b1a2015-09-08 08:41:51 -0700384 SkASSERT(fSubstageIndices.count() >= 2);
wangyix7ef45a12015-08-13 06:51:35 -0700385 fSubstageIndices.pop_back();
wangyix54a6b1a2015-09-08 08:41:51 -0700386 fSubstageIndices.back()++;
wangyix7ef45a12015-08-13 06:51:35 -0700387 int removeAt = fMangleString.findLastOf('_');
388 fMangleString.remove(removeAt, fMangleString.size() - removeAt);
389}