Create GrGLSLVaryingHandler class for program building

src/gpu/glsl/GrGLSLVarying.cpp

Index: src/gpu/glsl/GrGLSLVarying.cpp
diff --git a/src/gpu/glsl/GrGLSLVarying.cpp b/src/gpu/glsl/GrGLSLVarying.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..279dd5937e92a911b67891012a93cde96895b4f3
--- /dev/null
+++ b/src/gpu/glsl/GrGLSLVarying.cpp
@@ -0,0 +1,132 @@
+/*
+ * 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) {
+    GrSLType type = GrVertexAttribTypeToSLType(input->fType);
+    GrGLSLVertToFrag v(type);
+    this->addVarying(input->fName, &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) {
+    SkASSERT(varying);
+    if (varying->vsVarying()) {
+        this->addVertexVarying(name, precision, varying);
+    }
+    if (fProgramBuilder->primitiveProcessor().willUseGeoShader()) {
+        this->addGeomVarying(name, precision, varying);
+    }
+    if (varying->fsVarying()) {
+        this->addFragVarying(precision, varying);
+    }
+}
+
+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::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);
+}
+