Use noperspective interpolation for 2D draws

src/gpu/glsl/GrGLSLVarying.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "glsl/GrGLSLVarying.h"
 
 #include "glsl/GrGLSLProgramBuilder.h"
 
 void GrGLSLVaryingHandler::addPassThroughAttribute(const GrGeometryProcessor::Attribute* input,
-                                                   const char* output) {
+                                                   const char* output, GrSLPrecision precision) {
     GrSLType type = GrVertexAttribTypeToSLType(input->fType);
     GrGLSLVertToFrag v(type);
-    this->addVarying(input->fName, &v);
+    this->addVarying(input->fName, &v, precision);
+    this->writePassThroughAttribute(input, output, v);
+}
+
+void GrGLSLVaryingHandler::addFlatPassThroughAttribute(const GrGeometryProcessor::Attribute* input,
+                                                       const char* output,
+                                                       GrSLPrecision precision) {
+    GrSLType type = GrVertexAttribTypeToSLType(input->fType);
+    GrGLSLVertToFrag v(type);
+    this->addFlatVarying(input->fName, &v, precision);
+    this->writePassThroughAttribute(input, output, v);
+}
+
+void GrGLSLVaryingHandler::writePassThroughAttribute(const GrGeometryProcessor::Attribute* input,
+                                                     const char* output, const GrGLSLVarying& v) {
     fProgramBuilder->fVS.codeAppendf("%s = %s;", v.vsOut(), input->fName);
 
     if (fProgramBuilder->primitiveProcessor().willUseGeoShader()) {
         fProgramBuilder->fGS.codeAppendf("%s = %s[0];", v.gsOut(), v.gsIn());
     }
 
     fProgramBuilder->fFS.codeAppendf("%s = %s;", output, v.fsIn());
 }
 
-void GrGLSLVaryingHandler::addVarying(const char* name,
-                                      GrGLSLVarying* varying,
-                                      GrSLPrecision precision) {
+void GrGLSLVaryingHandler::internalAddVarying(const char* name,
+                                              GrGLSLVarying* varying,
+                                              GrSLPrecision precision,
+                                              bool flat) {
+    bool willUseGeoShader = fProgramBuilder->primitiveProcessor().willUseGeoShader();
     SkASSERT(varying);
+    SkASSERT(varying->vsVarying() || willUseGeoShader);

[egdaniel, 2016/02/12 03:55:07]

if we add this assert, shouldn't we also have SkASSERT(fsVarying() ||
willUseGeoShader) as well?

And if we do that just have one SkASSERT((vsVarying && fsVarying) ||
willUseGeoShader);

[Chris Dalton, 2016/02/12 16:25:28]

My idea behind that assert was that it made sure the fsIn didn't end up with an
empty string. I rearranged things so that's not an issues anymore and just took
out the assert.

+
+    VaryingInfo& v = fVaryings.push_back();

[egdaniel, 2016/02/12 03:55:07]

I don't necessarily dislike this VaryingInfo thing, but what exactly is it
buying us? Seems like it causes use to need to do the logic of setting the
in/out char variables twice, both below and again in finalize.

I guess the one thing it adds is that we will either have only flat or only
nopersepective modifier. But would it really be bad if we ended up with both?

[Chris Dalton, 2016/02/12 16:25:28]

Yeah, you get a compile error if you use both (which really makes sense -- if
you pick two interpolation modes, which one did you actually want?)

The idea of the VaryingInfo list is that you build up an internal structure of
what you want the varyings to be, then during onFinalize you compile that list
into ShaderVars based on information you might not have known while building the
original list.

Another option would be to add interpolation modifiers on the ShaderVar, and
during onFinalize make a pass that converts smooth -> noperspective. I don't
like that approach because interpolation modifiers only apply to varyings, so it
makes sense to handle them inside the varying class rather than at the ShaderVar
level.

[egdaniel, 2016/02/12 16:33:58]

Just throwing in an idea off your comment. Would it make most sense to have a
GrGLSLVaryingShaderVar which is subclassed off of GrGLSLShaderVar? Cause I
almost feel the ShaderVars already are doing the work of the VaryingInfo and
this would then give us the flexibility for different ShaderVar uses.

+    v.fType = varying->fType;
+    v.fPrecision = precision;
+    v.fIsFlat = flat;
+    v.fVisibility = kNone_GrShaderFlags;
     if (varying->vsVarying()) {
-        this->addVertexVarying(name, precision, varying);
+        v.fVisibility |= kVertex_GrShaderFlag;
+        fProgramBuilder->nameVariable(&v.fVsOut, 'v', name);
+        varying->fVsOut = v.fVsOut.c_str();
     }
-    if (fProgramBuilder->primitiveProcessor().willUseGeoShader()) {
-        this->addGeomVarying(name, precision, varying);
+    if (willUseGeoShader) {
+        v.fVisibility |= kGeometry_GrShaderFlag;
+        fProgramBuilder->nameVariable(&v.fGsOut, 'g', name);
+        varying->fGsIn = v.fVsOut.c_str();
+        varying->fGsOut = v.fGsOut.c_str();
     }
     if (varying->fsVarying()) {
-        this->addFragVarying(precision, varying);
+        v.fVisibility |= kFragment_GrShaderFlag;
+        varying->fFsIn = (willUseGeoShader ? v.fGsOut : v.fVsOut).c_str();
     }
 }
 
-void GrGLSLVaryingHandler::addVertexVarying(const char* name,
-                                            GrSLPrecision precision,
-                                            GrGLSLVarying* v) {
-    fVertexOutputs.push_back();
-    fVertexOutputs.back().setType(v->fType);
-    fVertexOutputs.back().setTypeModifier(GrGLSLShaderVar::kVaryingOut_TypeModifier);
-    fVertexOutputs.back().setPrecision(precision);
-    fProgramBuilder->nameVariable(fVertexOutputs.back().accessName(), 'v', name);
-    v->fVsOut = fVertexOutputs.back().getName().c_str();
-}
-void GrGLSLVaryingHandler::addGeomVarying(const char* name,
-                                          GrSLPrecision precision,
-                                          GrGLSLVarying* v) {
-    // if we have a GS take each varying in as an array
-    // and output as non-array.
-    if (v->vsVarying()) {
-        fGeomInputs.push_back();
-        fGeomInputs.back().setType(v->fType);
-        fGeomInputs.back().setTypeModifier(GrGLSLShaderVar::kVaryingIn_TypeModifier);
-        fGeomInputs.back().setPrecision(precision);
-        fGeomInputs.back().setUnsizedArray();
-        *fGeomInputs.back().accessName() = v->fVsOut;
-        v->fGsIn = v->fVsOut;
-    }
-
-    if (v->fsVarying()) {
-        fGeomOutputs.push_back();
-        fGeomOutputs.back().setType(v->fType);
-        fGeomOutputs.back().setTypeModifier(GrGLSLShaderVar::kVaryingOut_TypeModifier);
-        fGeomOutputs.back().setPrecision(precision);
-        fProgramBuilder->nameVariable(fGeomOutputs.back().accessName(), 'g', name);
-        v->fGsOut = fGeomOutputs.back().getName().c_str();
-    }
-}
-
-void GrGLSLVaryingHandler::addFragVarying(GrSLPrecision precision, GrGLSLVarying* v) {
-    v->fFsIn = v->fGsOut ? v->fGsOut : v->fVsOut;
-    fFragInputs.push_back().set(v->fType,
-                                GrGLSLShaderVar::kVaryingIn_TypeModifier,
-                                v->fFsIn,
-                                precision);
-}
-
 void GrGLSLVaryingHandler::emitAttributes(const GrGeometryProcessor& gp) {
     int vaCount = gp.numAttribs();
     for (int i = 0; i < vaCount; i++) {
         const GrGeometryProcessor::Attribute& attr = gp.getAttrib(i);
         this->addAttribute(GrShaderVar(attr.fName,
                                        GrVertexAttribTypeToSLType(attr.fType),
                                        GrShaderVar::kAttribute_TypeModifier,
                                        GrShaderVar::kNonArray,
                                        attr.fPrecision));
     }
 }
 
 void GrGLSLVaryingHandler::addAttribute(const GrShaderVar& var) {
     SkASSERT(GrShaderVar::kAttribute_TypeModifier == var.getTypeModifier());
     for (int j = 0; j < fVertexInputs.count(); ++j) {
         const GrGLSLShaderVar& attr = fVertexInputs[j];
         // if attribute already added, don't add it again
         if (attr.getName().equals(var.getName())) {
             return;
         }
     }
     fVertexInputs.push_back(var);
 }
 
+void GrGLSLVaryingHandler::setNoPerspective() {
+    const GrGLSLCaps& caps = *fProgramBuilder->glslCaps();
+    if (!caps.noperspectiveInterpolationSupport()) {
+        return;
+    }
+    if (const char* extension = caps.noperspectiveInterpolationExtensionString()) {
+        int bit = 1 << GrGLSLFragmentShaderBuilder::kNoPerspectiveInterpolation_GLSLPrivateFeature;
+        fProgramBuilder->fVS.addFeature(bit, extension);
+        if (fProgramBuilder->primitiveProcessor().willUseGeoShader()) {
+            fProgramBuilder->fGS.addFeature(bit, extension);
+        }
+        fProgramBuilder->fFS.addFeature(bit, extension);
+    }
+    fDefaultInterpolationModifier = "noperspective";
+}
+
 void GrGLSLVaryingHandler::finalize() {
+    for (int i = 0; i < fVaryings.count(); ++i) {
+        const VaryingInfo& v = this->fVaryings[i];
+        const char* modifier = v.fIsFlat ? "flat" : fDefaultInterpolationModifier;
+        if (v.fVisibility & kVertex_GrShaderFlag) {
+            fVertexOutputs.push_back().set(v.fType, GrShaderVar::kVaryingOut_TypeModifier, v.fVsOut,
+                                           v.fPrecision, nullptr, modifier);
+            if (v.fVisibility & kGeometry_GrShaderFlag) {
+                fGeomInputs.push_back().set(v.fType, GrShaderVar::kVaryingIn_TypeModifier, v.fVsOut,
+                                            GrShaderVar::kUnsizedArray, v.fPrecision, nullptr,
+                                            modifier);
+            }
+        }
+        if (v.fVisibility & kFragment_GrShaderFlag) {
+            const char* fsIn = v.fVsOut.c_str();
+            if (v.fVisibility & kGeometry_GrShaderFlag) {
+                fGeomOutputs.push_back().set(v.fType, GrGLSLShaderVar::kVaryingOut_TypeModifier,
+                                             v.fGsOut, v.fPrecision, nullptr, modifier);
+                fsIn = v.fGsOut.c_str();
+            }
+            fFragInputs.push_back().set(v.fType, GrShaderVar::kVaryingIn_TypeModifier, fsIn,
+                                        v.fPrecision, nullptr, modifier);
+        }
+    }
     this->onFinalize();
 }
 
 void GrGLSLVaryingHandler::appendDecls(const VarArray& vars, SkString* out) const {
     for (int i = 0; i < vars.count(); ++i) {
         vars[i].appendDecl(fProgramBuilder->glslCaps(), out);
         out->append(";");
     }
 }
 
 void GrGLSLVaryingHandler::getVertexDecls(SkString* inputDecls, SkString* outputDecls) const {
     this->appendDecls(fVertexInputs, inputDecls);
     this->appendDecls(fVertexOutputs, outputDecls);
 }
 
 void GrGLSLVaryingHandler::getGeomDecls(SkString* inputDecls, SkString* outputDecls) const {
     this->appendDecls(fGeomInputs, inputDecls);
     this->appendDecls(fGeomOutputs, outputDecls);
 }
 
 void GrGLSLVaryingHandler::getFragDecls(SkString* inputDecls, SkString* outputDecls) const {
     // We should not have any outputs in the fragment shader when using version 1.10
     SkASSERT(k110_GrGLSLGeneration != fProgramBuilder->glslCaps()->generation() ||
              fFragOutputs.empty());
     this->appendDecls(fFragInputs, inputDecls);
     this->appendDecls(fFragOutputs, outputDecls);
 }