GrGLSLFragmentShaderBuilder.cpp revision 15341a284e78651d2b47b89753044f8d6e7eda0a
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#include "GrGLSLFragmentShaderBuilder.h" 9#include "GrRenderTarget.h" 10#include "GrRenderTargetPriv.h" 11#include "gl/GrGLGpu.h" 12#include "glsl/GrGLSL.h" 13#include "glsl/GrGLSLCaps.h" 14#include "glsl/GrGLSLProgramBuilder.h" 15#include "glsl/GrGLSLUniformHandler.h" 16#include "glsl/GrGLSLVarying.h" 17 18const char* GrGLSLFragmentShaderBuilder::kDstColorName = "_dstColor"; 19 20static 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 32static 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) == 70 kGrBlendEquationCnt - kFirstAdvancedGrBlendEquation); 71} 72 73uint8_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); 79} 80 81GrGLSLFragmentShaderBuilder::GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program) 82 : GrGLSLFragmentBuilder(program) 83 , fSetupFragPosition(false) 84 , fHasCustomColorOutput(false) 85 , fCustomColorOutputIndex(-1) 86 , fHasSecondaryOutput(false) 87 , fUsedSampleOffsetArrays(0) 88 , fHasInitializedSampleMask(false) { 89 fSubstageIndices.push_back(0); 90#ifdef SK_DEBUG 91 fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures; 92 fHasReadDstColor = false; 93#endif 94} 95 96bool GrGLSLFragmentShaderBuilder::enableFeature(GLSLFeature feature) { 97 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps(); 98 switch (feature) { 99 case kStandardDerivatives_GLSLFeature: 100 if (!glslCaps.shaderDerivativeSupport()) { 101 return false; 102 } 103 if (const char* extension = glslCaps.shaderDerivativeExtensionString()) { 104 this->addFeature(1 << kStandardDerivatives_GLSLFeature, extension); 105 } 106 return true; 107 case kPixelLocalStorage_GLSLFeature: 108 if (glslCaps.pixelLocalStorageSize() <= 0) { 109 return false; 110 } 111 this->addFeature(1 << kPixelLocalStorage_GLSLFeature, 112 "GL_EXT_shader_pixel_local_storage"); 113 return true; 114 case kMultisampleInterpolation_GLSLFeature: 115 if (!glslCaps.multisampleInterpolationSupport()) { 116 return false; 117 } 118 if (const char* extension = glslCaps.multisampleInterpolationExtensionString()) { 119 this->addFeature(1 << kMultisampleInterpolation_GLSLFeature, extension); 120 } 121 return true; 122 default: 123 SkFAIL("Unexpected GLSLFeature requested."); 124 return false; 125 } 126} 127 128SkString GrGLSLFragmentShaderBuilder::ensureCoords2D(const GrShaderVar& coords) { 129 if (kVec3f_GrSLType != coords.getType()) { 130 SkASSERT(kVec2f_GrSLType == coords.getType()); 131 return coords.getName(); 132 } 133 134 SkString coords2D; 135 coords2D.printf("%s_ensure2D", coords.c_str()); 136 this->codeAppendf("\tvec2 %s = %s.xy / %s.z;", coords2D.c_str(), coords.c_str(), 137 coords.c_str()); 138 return coords2D; 139} 140 141const char* GrGLSLFragmentShaderBuilder::fragmentPosition() { 142 SkDEBUGCODE(fUsedProcessorFeatures |= GrProcessor::kFragmentPosition_RequiredFeature;) 143 144 const GrGLSLCaps* glslCaps = fProgramBuilder->glslCaps(); 145 // We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers 146 // to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the 147 // declaration varies in earlier GLSL specs. So it is simpler to omit it. 148 if (kTopLeft_GrSurfaceOrigin == this->getSurfaceOrigin()) { 149 fSetupFragPosition = true; 150 return "gl_FragCoord"; 151 } else if (const char* extension = glslCaps->fragCoordConventionsExtensionString()) { 152 if (!fSetupFragPosition) { 153 if (glslCaps->generation() < k150_GrGLSLGeneration) { 154 this->addFeature(1 << kFragCoordConventions_GLSLPrivateFeature, 155 extension); 156 } 157 fInputs.push_back().set(kVec4f_GrSLType, 158 GrGLSLShaderVar::kIn_TypeModifier, 159 "gl_FragCoord", 160 kDefault_GrSLPrecision, 161 "origin_upper_left"); 162 fSetupFragPosition = true; 163 } 164 return "gl_FragCoord"; 165 } else { 166 static const char* kTempName = "tmpXYFragCoord"; 167 static const char* kCoordName = "fragCoordYDown"; 168 if (!fSetupFragPosition) { 169 const char* rtHeightName; 170 171 fProgramBuilder->addRTHeightUniform("RTHeight", &rtHeightName); 172 173 // The Adreno compiler seems to be very touchy about access to "gl_FragCoord". 174 // Accessing glFragCoord.zw can cause a program to fail to link. Additionally, 175 // depending on the surrounding code, accessing .xy with a uniform involved can 176 // do the same thing. Copying gl_FragCoord.xy into a temp vec2 beforehand 177 // (and only accessing .xy) seems to "fix" things. 178 const char* precision = glslCaps->usesPrecisionModifiers() ? "highp " : ""; 179 this->codePrependf("\t%svec4 %s = vec4(%s.x, %s - %s.y, 1.0, 1.0);\n", 180 precision, kCoordName, kTempName, rtHeightName, kTempName); 181 this->codePrependf("%svec2 %s = gl_FragCoord.xy;", precision, kTempName); 182 fSetupFragPosition = true; 183 } 184 SkASSERT(fProgramBuilder->fUniformHandles.fRTHeightUni.isValid()); 185 return kCoordName; 186 } 187} 188 189const char* GrGLSLFragmentShaderBuilder::distanceVectorName() const { 190 return "fsDistanceVector"; 191} 192 193void GrGLSLFragmentShaderBuilder::appendOffsetToSample(const char* sampleIdx, Coordinates coords) { 194 SkASSERT(fProgramBuilder->header().fSamplePatternKey); 195 SkDEBUGCODE(fUsedProcessorFeatures |= GrProcessor::kSampleLocations_RequiredFeature); 196 if (kTopLeft_GrSurfaceOrigin == this->getSurfaceOrigin()) { 197 // With a top left origin, device and window space are equal, so we only use device coords. 198 coords = kSkiaDevice_Coordinates; 199 } 200 this->codeAppendf("%s[%s]", sample_offset_array_name(coords), sampleIdx); 201 fUsedSampleOffsetArrays |= (1 << coords); 202} 203 204void GrGLSLFragmentShaderBuilder::maskSampleCoverage(const char* mask, bool invert) { 205 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps(); 206 if (!glslCaps.sampleVariablesSupport()) { 207 SkDEBUGFAIL("Attempted to mask sample coverage without support."); 208 return; 209 } 210 if (const char* extension = glslCaps.sampleVariablesExtensionString()) { 211 this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension); 212 } 213 if (!fHasInitializedSampleMask) { 214 this->codePrependf("gl_SampleMask[0] = -1;"); 215 fHasInitializedSampleMask = true; 216 } 217 if (invert) { 218 this->codeAppendf("gl_SampleMask[0] &= ~(%s);", mask); 219 } else { 220 this->codeAppendf("gl_SampleMask[0] &= %s;", mask); 221 } 222} 223 224void GrGLSLFragmentShaderBuilder::overrideSampleCoverage(const char* mask) { 225 const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps(); 226 if (!glslCaps.sampleMaskOverrideCoverageSupport()) { 227 SkDEBUGFAIL("Attempted to override sample coverage without support."); 228 return; 229 } 230 SkASSERT(glslCaps.sampleVariablesSupport()); 231 if (const char* extension = glslCaps.sampleVariablesExtensionString()) { 232 this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension); 233 } 234 if (this->addFeature(1 << kSampleMaskOverrideCoverage_GLSLPrivateFeature, 235 "GL_NV_sample_mask_override_coverage")) { 236 // Redeclare gl_SampleMask with layout(override_coverage) if we haven't already. 237 fOutputs.push_back().set(kInt_GrSLType, GrShaderVar::kOut_TypeModifier, 238 "gl_SampleMask", 1, kHigh_GrSLPrecision, 239 "override_coverage"); 240 } 241 this->codeAppendf("gl_SampleMask[0] = %s;", mask); 242 fHasInitializedSampleMask = true; 243} 244 245const char* GrGLSLFragmentShaderBuilder::dstColor() { 246 SkDEBUGCODE(fHasReadDstColor = true;) 247 248 const char* override = fProgramBuilder->primitiveProcessor().getDestColorOverride(); 249 if (override != nullptr) { 250 return override; 251 } 252 253 const GrGLSLCaps* glslCaps = fProgramBuilder->glslCaps(); 254 if (glslCaps->fbFetchSupport()) { 255 this->addFeature(1 << kFramebufferFetch_GLSLPrivateFeature, 256 glslCaps->fbFetchExtensionString()); 257 258 // Some versions of this extension string require declaring custom color output on ES 3.0+ 259 const char* fbFetchColorName = glslCaps->fbFetchColorName(); 260 if (glslCaps->fbFetchNeedsCustomOutput()) { 261 this->enableCustomOutput(); 262 fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier); 263 fbFetchColorName = DeclaredColorOutputName(); 264 // Set the dstColor to an intermediate variable so we don't override it with the output 265 this->codeAppendf("vec4 %s = %s;", kDstColorName, fbFetchColorName); 266 } else { 267 return fbFetchColorName; 268 } 269 } 270 return kDstColorName; 271} 272 273void GrGLSLFragmentShaderBuilder::enableAdvancedBlendEquationIfNeeded(GrBlendEquation equation) { 274 SkASSERT(GrBlendEquationIsAdvanced(equation)); 275 276 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps(); 277 if (!caps.mustEnableAdvBlendEqs()) { 278 return; 279 } 280 281 this->addFeature(1 << kBlendEquationAdvanced_GLSLPrivateFeature, 282 "GL_KHR_blend_equation_advanced"); 283 if (caps.mustEnableSpecificAdvBlendEqs()) { 284 this->addLayoutQualifier(specific_layout_qualifier_name(equation), kOut_InterfaceQualifier); 285 } else { 286 this->addLayoutQualifier("blend_support_all_equations", kOut_InterfaceQualifier); 287 } 288} 289 290void GrGLSLFragmentShaderBuilder::enableCustomOutput() { 291 if (!fHasCustomColorOutput) { 292 fHasCustomColorOutput = true; 293 fCustomColorOutputIndex = fOutputs.count(); 294 fOutputs.push_back().set(kVec4f_GrSLType, 295 GrGLSLShaderVar::kOut_TypeModifier, 296 DeclaredColorOutputName()); 297 fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back()); 298 } 299} 300 301void GrGLSLFragmentShaderBuilder::enableSecondaryOutput() { 302 SkASSERT(!fHasSecondaryOutput); 303 fHasSecondaryOutput = true; 304 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps(); 305 if (const char* extension = caps.secondaryOutputExtensionString()) { 306 this->addFeature(1 << kBlendFuncExtended_GLSLPrivateFeature, extension); 307 } 308 309 // If the primary output is declared, we must declare also the secondary output 310 // and vice versa, since it is not allowed to use a built-in gl_FragColor and a custom 311 // output. The condition also co-incides with the condition in whici GLES SL 2.0 312 // requires the built-in gl_SecondaryFragColorEXT, where as 3.0 requires a custom output. 313 if (caps.mustDeclareFragmentShaderOutput()) { 314 fOutputs.push_back().set(kVec4f_GrSLType, GrGLSLShaderVar::kOut_TypeModifier, 315 DeclaredSecondaryColorOutputName()); 316 fProgramBuilder->finalizeFragmentSecondaryColor(fOutputs.back()); 317 } 318} 319 320const char* GrGLSLFragmentShaderBuilder::getPrimaryColorOutputName() const { 321 return fHasCustomColorOutput ? DeclaredColorOutputName() : "gl_FragColor"; 322} 323 324void GrGLSLFragmentBuilder::declAppendf(const char* fmt, ...) { 325 va_list argp; 326 va_start(argp, fmt); 327 inputs().appendVAList(fmt, argp); 328 va_end(argp); 329} 330 331const char* GrGLSLFragmentShaderBuilder::getSecondaryColorOutputName() const { 332 const GrGLSLCaps& caps = *fProgramBuilder->glslCaps(); 333 return caps.mustDeclareFragmentShaderOutput() ? DeclaredSecondaryColorOutputName() 334 : "gl_SecondaryFragColorEXT"; 335} 336 337GrSurfaceOrigin GrGLSLFragmentShaderBuilder::getSurfaceOrigin() const { 338 SkASSERT(fProgramBuilder->header().fSurfaceOriginKey); 339 return static_cast<GrSurfaceOrigin>(fProgramBuilder->header().fSurfaceOriginKey); 340 341 GR_STATIC_ASSERT(1 == kTopLeft_GrSurfaceOrigin); 342 GR_STATIC_ASSERT(2 == kBottomLeft_GrSurfaceOrigin); 343} 344 345void GrGLSLFragmentShaderBuilder::onFinalize() { 346 fProgramBuilder->varyingHandler()->getFragDecls(&this->inputs(), &this->outputs()); 347 GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, 348 *fProgramBuilder->glslCaps(), 349 &this->precisionQualifier()); 350 if (fUsedSampleOffsetArrays & (1 << kSkiaDevice_Coordinates)) { 351 this->defineSampleOffsetArray(sample_offset_array_name(kSkiaDevice_Coordinates), 352 SkMatrix::MakeTrans(-0.5f, -0.5f)); 353 } 354 if (fUsedSampleOffsetArrays & (1 << kGLSLWindow_Coordinates)) { 355 // With a top left origin, device and window space are equal, so we only use device coords. 356 SkASSERT(kBottomLeft_GrSurfaceOrigin == this->getSurfaceOrigin()); 357 SkMatrix m; 358 m.setScale(1, -1); 359 m.preTranslate(-0.5f, -0.5f); 360 this->defineSampleOffsetArray(sample_offset_array_name(kGLSLWindow_Coordinates), m); 361 } 362} 363 364void GrGLSLFragmentShaderBuilder::defineSampleOffsetArray(const char* name, const SkMatrix& m) { 365 SkASSERT(fProgramBuilder->caps()->sampleLocationsSupport()); 366 const GrPipeline& pipeline = fProgramBuilder->pipeline(); 367 const GrRenderTargetPriv& rtp = pipeline.getRenderTarget()->renderTargetPriv(); 368 const GrGpu::MultisampleSpecs& specs = rtp.getMultisampleSpecs(pipeline.getStencil()); 369 SkSTArray<16, SkPoint, true> offsets; 370 offsets.push_back_n(specs.fEffectiveSampleCnt); 371 m.mapPoints(offsets.begin(), specs.fSampleLocations, specs.fEffectiveSampleCnt); 372 this->definitions().append("const "); 373 if (fProgramBuilder->glslCaps()->usesPrecisionModifiers()) { 374 this->definitions().append("highp "); 375 } 376 this->definitions().appendf("vec2 %s[] = vec2[](", name); 377 for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) { 378 this->definitions().appendf("vec2(%f, %f)", offsets[i].x(), offsets[i].y()); 379 this->definitions().append(i + 1 != specs.fEffectiveSampleCnt ? ", " : ");\n"); 380 } 381} 382 383void GrGLSLFragmentShaderBuilder::onBeforeChildProcEmitCode() { 384 SkASSERT(fSubstageIndices.count() >= 1); 385 fSubstageIndices.push_back(0); 386 // second-to-last value in the fSubstageIndices stack is the index of the child proc 387 // at that level which is currently emitting code. 388 fMangleString.appendf("_c%d", fSubstageIndices[fSubstageIndices.count() - 2]); 389} 390 391void GrGLSLFragmentShaderBuilder::onAfterChildProcEmitCode() { 392 SkASSERT(fSubstageIndices.count() >= 2); 393 fSubstageIndices.pop_back(); 394 fSubstageIndices.back()++; 395 int removeAt = fMangleString.findLastOf('_'); 396 fMangleString.remove(removeAt, fMangleString.size() - removeAt); 397} 398