Add "sample locations" feature to GrProcessor

src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLSLFragmentShaderBuilder.h"
 #include "GrRenderTarget.h"
 #include "gl/GrGLGpu.h"
@@ skipping 152 matching lines @@
             this->codePrependf("\t%svec4 %s = vec4(%s.x, %s - %s.y, 1.0, 1.0);\n",
                                precision, kCoordName, kTempName, rtHeightName, kTempName);
             this->codePrependf("%svec2 %s = gl_FragCoord.xy;", precision, kTempName);
             fSetupFragPosition = true;
         }
         SkASSERT(fProgramBuilder->fUniformHandles.fRTHeightUni.isValid());
         return kCoordName;
     }
 }
 
+void GrGLSLFragmentShaderBuilder::appendSampleOffset(const char* sampleIdx) {
+    SkASSERT(fProgramBuilder->pipeline().hasSampleLocations());

[Chris Dalton, 2016/02/23 01:51:01]

I guess maskSampleCoverage() does a test/SkDEBUGFAIL/return instead of just an
assert.

Is there a preference on how to handle this? I don't see much precedent in this
file for asserts.

+    this->codeAppendf("sampleOffsets[%s]", sampleIdx);
+}
+
 void GrGLSLFragmentShaderBuilder::maskSampleCoverage(const char* mask, bool invert) {
     const GrGLSLCaps& glslCaps = *fProgramBuilder->glslCaps();
     if (!glslCaps.sampleVariablesSupport()) {
         SkDEBUGFAIL("Attempted to mask sample coverage without support.");
         return;
     }
     if (const char* extension = glslCaps.sampleVariablesExtensionString()) {
         this->addFeature(1 << kSampleVariables_GLSLPrivateFeature, extension);
     }
     if (!fHasInitializedSampleMask) {
@@ skipping 116 matching lines @@
     const GrGLSLCaps& caps = *fProgramBuilder->glslCaps();
     return caps.mustDeclareFragmentShaderOutput() ? DeclaredSecondaryColorOutputName()
                                                   : "gl_SecondaryFragColorEXT";
 }
 
 void GrGLSLFragmentShaderBuilder::onFinalize() {
     fProgramBuilder->varyingHandler()->getFragDecls(&this->inputs(), &this->outputs());
     GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision,
                                                  *fProgramBuilder->glslCaps(),
                                                  &this->precisionQualifier());
+    if (fProgramBuilder->pipeline().hasSampleLocations()) {
+        const GrPipeline& pipeline = fProgramBuilder->pipeline();
+        int effectiveSampleCnt = pipeline.effectiveSampleCount();
+        const SkPoint* sampleLocations = pipeline.getSampleLocations();
+        this->definitions().append("const ");
+        if (fProgramBuilder->glslCaps()->usesPrecisionModifiers()) {
+            this->definitions().append("highp ");
+        }
+        this->definitions().appendf("vec2 sampleOffsets[] = vec2[](");
+        for (int i = 0; i < effectiveSampleCnt; ++i) {
+            this->definitions().appendf("vec2(%f, %f)%s",
+                                        sampleLocations[i].x() - 0.5f,
+                                        sampleLocations[i].y() - 0.5f,
+                                        i + 1 != effectiveSampleCnt ? ", " : ");\n");
+        }
+        SkASSERT(fProgramBuilder->header().fSamplePatternKey == pipeline.getSamplePatternID());
+    }
 }
 
 void GrGLSLFragmentShaderBuilder::onBeforeChildProcEmitCode() {
     SkASSERT(fSubstageIndices.count() >= 1);
     fSubstageIndices.push_back(0);
     // second-to-last value in the fSubstageIndices stack is the index of the child proc
     // at that level which is currently emitting code.
     fMangleString.appendf("_c%d", fSubstageIndices[fSubstageIndices.count() - 2]);
 }
 
 void GrGLSLFragmentShaderBuilder::onAfterChildProcEmitCode() {
     SkASSERT(fSubstageIndices.count() >= 2);
     fSubstageIndices.pop_back();
     fSubstageIndices.back()++;
     int removeAt = fMangleString.findLastOf('_');
     fMangleString.remove(removeAt, fMangleString.size() - removeAt);
 }