Adds local coords to GrEffect system.

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 62 matching lines @@
     };
 
     typedef SkTArray<TextureSampler> TextureSamplerArray;
 
     enum ShaderType {
         kVertex_ShaderType   = 0x1,
         kGeometry_ShaderType = 0x2,
         kFragment_ShaderType = 0x4,
     };
 
-    GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&);
+    GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&, bool explicitLocalCoords);
 
     /**
      * Called by GrGLEffects to add code to one of the shaders.
      */
     void vsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
         va_list args;
         va_start(args, format);
         this->codeAppendf(kVertex_ShaderType, format, args);
         va_end(args);
     }
@@ skipping 104 matching lines @@
 
     /** Returns a variable name that represents the position of the fragment in the FS. The position
         is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
     const char* fragmentPosition();
 
     /** Returns a vertex attribute that represents the vertex position in the VS. This is the
         pre-matrix position and is commonly used by effects to compute texture coords via a matrix.
       */
     const GrGLShaderVar& positionAttribute() const { return *fPositionVar; }
 
+    /** Returns a vertex attribute that represents the local coords in the VS. This may be the same
+        as positionAttribute() or it may not be. It depends upon whether the rendering code
+        specified explicit local coords or not in the GrDrawState. */
+    const GrGLShaderVar& localCoordsAttribute() const { return *fLocalCoordsVar; }
+
+    /**
+     * Are explicit local coordinates provided as input to the vertex shader.
+     */
+    bool hasExplicitLocalCoords() const { return (fLocalCoordsVar != fPositionVar); }
+
     /**
      * Interfaces used by GrGLProgram.
      * TODO: Hide these from the GrEffects using friend or splitting this into two related classes.
      * Also, GrGLProgram's shader string construction should be moved to this class.
      */
 
     /** Called after building is complete to get the final shader string. */
     void getShader(ShaderType, SkString*) const;
 
     void setCurrentStage(int stageIdx) { fCurrentStageIdx = stageIdx; }
     void setNonStage() { fCurrentStageIdx = kNonStageIdx; }
     // TODO: move remainder of shader code generation to this class and call this privately
     // Handles of sampler uniforms generated for the effect are appended to samplerHandles.
     GrGLEffect* createAndEmitGLEffect(
                                 const GrEffectStage& stage,
                                 GrBackendEffectFactory::EffectKey key,
                                 const char* fsInColor, // NULL means no incoming color
                                 const char* fsOutColor,
-                                const char* vsInCoord,
                                 SkTArray<GrGLUniformManager::UniformHandle, true>* samplerHandles);
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
 
     struct AttributePair {
         void set(int index, const SkString& name) {
             fIndex = index; fName = name;
         }
         int      fIndex;
         SkString fName;
     };
@@ skipping 46 matching lines @@
     SkString                            fFSCode;
     SkString                            fVSCode;
     SkString                            fGSCode;
 
     bool                                fSetupFragPosition;
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
+    GrGLShaderVar*                      fLocalCoordsVar;
+
 };
 
 #endif