Create GrGLSLVaryingHandler class for program building

src/gpu/gl/GrGLProgramDataManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "gl/GrGLProgramDataManager.h"
 #include "gl/GrGLGpu.h"
 
 #define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT) \
          SkASSERT(arrayCount <= uni.fArrayCount || \
                   (1 == arrayCount && GrGLSLShaderVar::kNonArray == uni.fArrayCount))
 
 GrGLProgramDataManager::GrGLProgramDataManager(GrGLGpu* gpu, GrGLuint programID,
                                                const UniformInfoArray& uniforms,
-                                               const SeparableVaryingInfoArray& separableVaryings)
+                                               const VaryingInfoArray& pathProcVaryings)
     : fGpu(gpu)
     , fProgramID(programID) {
     int count = uniforms.count();
     fUniforms.push_back_n(count);
     for (int i = 0; i < count; i++) {
         Uniform& uniform = fUniforms[i];
         const UniformInfo& builderUniform = uniforms[i];
         SkASSERT(GrGLSLShaderVar::kNonArray == builderUniform.fVariable.getArrayCount() ||
                  builderUniform.fVariable.getArrayCount() > 0);
         SkDEBUGCODE(
             uniform.fArrayCount = builderUniform.fVariable.getArrayCount();
             uniform.fType = builderUniform.fVariable.getType();
         );
         // TODO: Move the Xoom uniform array in both FS and VS bug workaround here.
 
         if (GrGLProgramBuilder::kVertex_Visibility & builderUniform.fVisibility) {
             uniform.fVSLocation = builderUniform.fLocation;
         } else {
             uniform.fVSLocation = kUnusedUniform;
         }
         if (GrGLProgramBuilder::kFragment_Visibility & builderUniform.fVisibility) {
             uniform.fFSLocation = builderUniform.fLocation;
         } else {
             uniform.fFSLocation = kUnusedUniform;
         }
     }
 
     // NVPR programs have separable varyings
-    count = separableVaryings.count();
-    fSeparableVaryings.push_back_n(count);
+    count = pathProcVaryings.count();
+    fPathProcVaryings.push_back_n(count);
     for (int i = 0; i < count; i++) {
         SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
-        SeparableVarying& separableVarying = fSeparableVaryings[i];
-        const SeparableVaryingInfo& builderSeparableVarying = separableVaryings[i];
-        SkASSERT(GrGLSLShaderVar::kNonArray == builderSeparableVarying.fVariable.getArrayCount() ||
-                 builderSeparableVarying.fVariable.getArrayCount() > 0);
+        PathProcVarying& pathProcVarying = fPathProcVaryings[i];
+        const VaryingInfo& builderPathProcVarying = pathProcVaryings[i];
+        SkASSERT(GrGLSLShaderVar::kNonArray == builderPathProcVarying.fVariable.getArrayCount() ||
+                 builderPathProcVarying.fVariable.getArrayCount() > 0);
         SkDEBUGCODE(
-            separableVarying.fArrayCount = builderSeparableVarying.fVariable.getArrayCount();
-            separableVarying.fType = builderSeparableVarying.fVariable.getType();
+            pathProcVarying.fArrayCount = builderPathProcVarying.fVariable.getArrayCount();
+            pathProcVarying.fType = builderPathProcVarying.fVariable.getType();
         );
-        separableVarying.fLocation = builderSeparableVarying.fLocation;
+        pathProcVarying.fLocation = builderPathProcVarying.fLocation;
     }
 }
 
 void GrGLProgramDataManager::setSampler(UniformHandle u, int texUnit) const {
     const Uniform& uni = fUniforms[u.toIndex()];
     SkASSERT(uni.fType == kSampler2D_GrSLType);
     SkASSERT(GrGLSLShaderVar::kNonArray == uni.fArrayCount);
     // FIXME: We still insert a single sampler uniform for every stage. If the shader does not
     // reference the sampler then the compiler may have optimized it out. Uncomment this assert
     // once stages insert their own samplers.
@@ skipping 199 matching lines @@
         matrix.get(SkMatrix::kMSkewX),
         matrix.get(SkMatrix::kMScaleY),
         matrix.get(SkMatrix::kMPersp1),
         matrix.get(SkMatrix::kMTransX),
         matrix.get(SkMatrix::kMTransY),
         matrix.get(SkMatrix::kMPersp2),
     };
     this->setMatrix3f(u, mt);
 }
 
-void GrGLProgramDataManager::setPathFragmentInputTransform(SeparableVaryingHandle u,
+void GrGLProgramDataManager::setPathFragmentInputTransform(VaryingHandle u,
                                                            int components,
                                                            const SkMatrix& matrix) const {
     SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
-    const SeparableVarying& fragmentInput = fSeparableVaryings[u.toIndex()];
+    const PathProcVarying& fragmentInput = fPathProcVaryings[u.toIndex()];
 
     SkASSERT((components == 2 && fragmentInput.fType == kVec2f_GrSLType) ||
               (components == 3 && fragmentInput.fType == kVec3f_GrSLType));
 
     fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgramID,
                                                                   fragmentInput.fLocation,
                                                                   GR_GL_OBJECT_LINEAR,
                                                                   components,
                                                                   matrix);
 }
 
 #ifdef SK_DEBUG
 void GrGLProgramDataManager::printUnused(const Uniform& uni) const {
     if (kUnusedUniform == uni.fFSLocation && kUnusedUniform == uni.fVSLocation) {
         GrCapsDebugf(fGpu->caps(), "Unused uniform in shader\n");
     }
 }
 #endif