Home | History | Annotate | Download | only in glsl 
      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 "GrShaderCaps.h"
     12 #include "gl/GrGLGpu.h"
     13 #include "glsl/GrGLSLProgramBuilder.h"
     14 #include "glsl/GrGLSLUniformHandler.h"
     15 #include "glsl/GrGLSLVarying.h"
     16 #include "../private/GrGLSL.h"
     17 
     18 const char* GrGLSLFragmentShaderBuilder::kDstColorName = "_dstColor";
     19 
     20 static 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 
     32 static 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 
     73 uint8_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 
     81 GrGLSLFragmentShaderBuilder::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     , fDefaultPrecision(kMedium_GrSLPrecision) {
     90     fSubstageIndices.push_back(0);
     91 #ifdef SK_DEBUG
     92     fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures;
     93     fHasReadDstColor = false;
     94 #endif
     95 }
     96 
     97 bool GrGLSLFragmentShaderBuilder::enableFeature(GLSLFeature feature) {
     98     const GrShaderCaps& shaderCaps = *fProgramBuilder->shaderCaps();
     99     switch (feature) {
    100         case kMultisampleInterpolation_GLSLFeature:
    101             if (!shaderCaps.multisampleInterpolationSupport()) {
    102                 return false;
    103             }
    104             if (const char* extension = shaderCaps.multisampleInterpolationExtensionString()) {
    105                 this->addFeature(1 << kMultisampleInterpolation_GLSLFeature, extension);
    106             }
    107             return true;
    108         default:
    109             SkFAIL("Unexpected GLSLFeature requested.");
    110             return false;
    111     }
    112 }
    113 
    114 SkString GrGLSLFragmentShaderBuilder::ensureCoords2D(const GrShaderVar& coords) {
    115     if (kVec3f_GrSLType != coords.getType()) {
    116         SkASSERT(kVec2f_GrSLType == coords.getType());
    117         return coords.getName();
    118     }
    119 
    120     SkString coords2D;
    121     coords2D.printf("%s_ensure2D", coords.c_str());
    122     this->codeAppendf("\tvec2 %s = %s.xy / %s.z;", coords2D.c_str(), coords.c_str(),
    123                       coords.c_str());
    124     return coords2D;
    125 }
    126 
    127 void GrGLSLFragmentShaderBuilder::appendOffsetToSample(const char* sampleIdx, Coordinates coords) {
    128     SkASSERT(fProgramBuilder->header().fSamplePatternKey);
    129     SkDEBUGCODE(fUsedProcessorFeatures |= GrProcessor::kSampleLocations_RequiredFeature);
    130     if (kTopLeft_GrSurfaceOrigin == this->getSurfaceOrigin()) {
    131         // With a top left origin, device and window space are equal, so we only use device coords.
    132         coords = kSkiaDevice_Coordinates;
    133     }
    134     this->codeAppendf("%s[%s]", sample_offset_array_name(coords), sampleIdx);
    135     fUsedSampleOffsetArrays |= (1 << coords);
    136 }
    137 
    138 void GrGLSLFragmentShaderBuilder::maskSampleCoverage(const char* mask, bool invert) {
    139     const GrShaderCaps& shaderCaps = *fProgramBuilder->shaderCaps();
    140     if (!shaderCaps.sampleVariablesSupport()) {
    141         SkDEBUGFAIL("Attempted to mask sample coverage without support.");
    142         return;
    143     }
    144     if (const char* extension = shaderCaps.sampleVariablesExtensionString()) {
    145         this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension);
    146     }
    147     if (!fHasInitializedSampleMask) {
    148         this->codePrependf("gl_SampleMask[0] = -1;");
    149         fHasInitializedSampleMask = true;
    150     }
    151     if (invert) {
    152         this->codeAppendf("gl_SampleMask[0] &= ~(%s);", mask);
    153     } else {
    154         this->codeAppendf("gl_SampleMask[0] &= %s;", mask);
    155     }
    156 }
    157 
    158 void GrGLSLFragmentShaderBuilder::overrideSampleCoverage(const char* mask) {
    159     const GrShaderCaps& shaderCaps = *fProgramBuilder->shaderCaps();
    160     if (!shaderCaps.sampleMaskOverrideCoverageSupport()) {
    161         SkDEBUGFAIL("Attempted to override sample coverage without support.");
    162         return;
    163     }
    164     SkASSERT(shaderCaps.sampleVariablesSupport());
    165     if (const char* extension = shaderCaps.sampleVariablesExtensionString()) {
    166         this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension);
    167     }
    168     if (this->addFeature(1 << kSampleMaskOverrideCoverage_GLSLPrivateFeature,
    169                          "GL_NV_sample_mask_override_coverage")) {
    170         // Redeclare gl_SampleMask with layout(override_coverage) if we haven't already.
    171         fOutputs.push_back().set(kInt_GrSLType, "gl_SampleMask", 1, GrShaderVar::kOut_TypeModifier,
    172                                  kHigh_GrSLPrecision, "override_coverage");
    173     }
    174     this->codeAppendf("gl_SampleMask[0] = %s;", mask);
    175     fHasInitializedSampleMask = true;
    176 }
    177 
    178 void GrGLSLFragmentShaderBuilder::elevateDefaultPrecision(GrSLPrecision precision) {
    179     fDefaultPrecision = SkTMax(fDefaultPrecision, precision);
    180 }
    181 
    182 const char* GrGLSLFragmentShaderBuilder::dstColor() {
    183     SkDEBUGCODE(fHasReadDstColor = true;)
    184 
    185     const char* override = fProgramBuilder->primitiveProcessor().getDestColorOverride();
    186     if (override != nullptr) {
    187         return override;
    188     }
    189 
    190     const GrShaderCaps* shaderCaps = fProgramBuilder->shaderCaps();
    191     if (shaderCaps->fbFetchSupport()) {
    192         this->addFeature(1 << kFramebufferFetch_GLSLPrivateFeature,
    193                          shaderCaps->fbFetchExtensionString());
    194 
    195         // Some versions of this extension string require declaring custom color output on ES 3.0+
    196         const char* fbFetchColorName = shaderCaps->fbFetchColorName();
    197         if (shaderCaps->fbFetchNeedsCustomOutput()) {
    198             this->enableCustomOutput();
    199             fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier);
    200             fbFetchColorName = DeclaredColorOutputName();
    201             // Set the dstColor to an intermediate variable so we don't override it with the output
    202             this->codeAppendf("vec4 %s = %s;", kDstColorName, fbFetchColorName);
    203         } else {
    204             return fbFetchColorName;
    205         }
    206     }
    207     return kDstColorName;
    208 }
    209 
    210 void GrGLSLFragmentShaderBuilder::enableAdvancedBlendEquationIfNeeded(GrBlendEquation equation) {
    211     SkASSERT(GrBlendEquationIsAdvanced(equation));
    212 
    213     const GrShaderCaps& caps = *fProgramBuilder->shaderCaps();
    214     if (!caps.mustEnableAdvBlendEqs()) {
    215         return;
    216     }
    217 
    218     this->addFeature(1 << kBlendEquationAdvanced_GLSLPrivateFeature,
    219                      "GL_KHR_blend_equation_advanced");
    220     if (caps.mustEnableSpecificAdvBlendEqs()) {
    221         this->addLayoutQualifier(specific_layout_qualifier_name(equation), kOut_InterfaceQualifier);
    222     } else {
    223         this->addLayoutQualifier("blend_support_all_equations", kOut_InterfaceQualifier);
    224     }
    225 }
    226 
    227 void GrGLSLFragmentShaderBuilder::enableCustomOutput() {
    228     if (!fHasCustomColorOutput) {
    229         fHasCustomColorOutput = true;
    230         fCustomColorOutputIndex = fOutputs.count();
    231         fOutputs.push_back().set(kVec4f_GrSLType, DeclaredColorOutputName(),
    232                                  GrShaderVar::kOut_TypeModifier);
    233         fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back());
    234     }
    235 }
    236 
    237 void GrGLSLFragmentShaderBuilder::enableSecondaryOutput() {
    238     SkASSERT(!fHasSecondaryOutput);
    239     fHasSecondaryOutput = true;
    240     const GrShaderCaps& caps = *fProgramBuilder->shaderCaps();
    241     if (const char* extension = caps.secondaryOutputExtensionString()) {
    242         this->addFeature(1 << kBlendFuncExtended_GLSLPrivateFeature, extension);
    243     }
    244 
    245     // If the primary output is declared, we must declare also the secondary output
    246     // and vice versa, since it is not allowed to use a built-in gl_FragColor and a custom
    247     // output. The condition also co-incides with the condition in whici GLES SL 2.0
    248     // requires the built-in gl_SecondaryFragColorEXT, where as 3.0 requires a custom output.
    249     if (caps.mustDeclareFragmentShaderOutput()) {
    250         fOutputs.push_back().set(kVec4f_GrSLType, DeclaredSecondaryColorOutputName(),
    251                                  GrShaderVar::kOut_TypeModifier);
    252         fProgramBuilder->finalizeFragmentSecondaryColor(fOutputs.back());
    253     }
    254 }
    255 
    256 const char* GrGLSLFragmentShaderBuilder::getPrimaryColorOutputName() const {
    257     return fHasCustomColorOutput ? DeclaredColorOutputName() : "sk_FragColor";
    258 }
    259 
    260 void GrGLSLFragmentBuilder::declAppendf(const char* fmt, ...) {
    261     va_list argp;
    262     va_start(argp, fmt);
    263     inputs().appendVAList(fmt, argp);
    264     va_end(argp);
    265 }
    266 
    267 const char* GrGLSLFragmentShaderBuilder::getSecondaryColorOutputName() const {
    268     const GrShaderCaps& caps = *fProgramBuilder->shaderCaps();
    269     return caps.mustDeclareFragmentShaderOutput() ? DeclaredSecondaryColorOutputName()
    270                                                   : "gl_SecondaryFragColorEXT";
    271 }
    272 
    273 GrSurfaceOrigin GrGLSLFragmentShaderBuilder::getSurfaceOrigin() const {
    274     SkASSERT(fProgramBuilder->header().fSurfaceOriginKey);
    275     return static_cast<GrSurfaceOrigin>(fProgramBuilder->header().fSurfaceOriginKey);
    276 
    277     GR_STATIC_ASSERT(1 == kTopLeft_GrSurfaceOrigin);
    278     GR_STATIC_ASSERT(2 == kBottomLeft_GrSurfaceOrigin);
    279 }
    280 
    281 void GrGLSLFragmentShaderBuilder::onFinalize() {
    282     fProgramBuilder->varyingHandler()->getFragDecls(&this->inputs(), &this->outputs());
    283     GrGLSLAppendDefaultFloatPrecisionDeclaration(fDefaultPrecision,
    284                                                  *fProgramBuilder->shaderCaps(),
    285                                                  &this->precisionQualifier());
    286     if (fUsedSampleOffsetArrays & (1 << kSkiaDevice_Coordinates)) {
    287         this->defineSampleOffsetArray(sample_offset_array_name(kSkiaDevice_Coordinates),
    288                                       SkMatrix::MakeTrans(-0.5f, -0.5f));
    289     }
    290     if (fUsedSampleOffsetArrays & (1 << kGLSLWindow_Coordinates)) {
    291         // With a top left origin, device and window space are equal, so we only use device coords.
    292         SkASSERT(kBottomLeft_GrSurfaceOrigin == this->getSurfaceOrigin());
    293         SkMatrix m;
    294         m.setScale(1, -1);
    295         m.preTranslate(-0.5f, -0.5f);
    296         this->defineSampleOffsetArray(sample_offset_array_name(kGLSLWindow_Coordinates), m);
    297     }
    298 }
    299 
    300 void GrGLSLFragmentShaderBuilder::defineSampleOffsetArray(const char* name, const SkMatrix& m) {
    301     SkASSERT(fProgramBuilder->caps()->sampleLocationsSupport());
    302     const GrPipeline& pipeline = fProgramBuilder->pipeline();
    303     const GrRenderTargetPriv& rtp = pipeline.getRenderTarget()->renderTargetPriv();
    304     const GrGpu::MultisampleSpecs& specs = rtp.getMultisampleSpecs(pipeline);
    305     SkSTArray<16, SkPoint, true> offsets;
    306     offsets.push_back_n(specs.fEffectiveSampleCnt);
    307     m.mapPoints(offsets.begin(), specs.fSampleLocations, specs.fEffectiveSampleCnt);
    308     this->definitions().appendf("const highp vec2 %s[] = vec2[](", name);
    309     for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) {
    310         this->definitions().appendf("vec2(%f, %f)", offsets[i].x(), offsets[i].y());
    311         this->definitions().append(i + 1 != specs.fEffectiveSampleCnt ? ", " : ");\n");
    312     }
    313 }
    314 
    315 void GrGLSLFragmentShaderBuilder::onBeforeChildProcEmitCode() {
    316     SkASSERT(fSubstageIndices.count() >= 1);
    317     fSubstageIndices.push_back(0);
    318     // second-to-last value in the fSubstageIndices stack is the index of the child proc
    319     // at that level which is currently emitting code.
    320     fMangleString.appendf("_c%d", fSubstageIndices[fSubstageIndices.count() - 2]);
    321 }
    322 
    323 void GrGLSLFragmentShaderBuilder::onAfterChildProcEmitCode() {
    324     SkASSERT(fSubstageIndices.count() >= 2);
    325     fSubstageIndices.pop_back();
    326     fSubstageIndices.back()++;
    327     int removeAt = fMangleString.findLastOf('_');
    328     fMangleString.remove(removeAt, fMangleString.size() - removeAt);
    329 }
    330