Refactor position computation to enable device space "nudge"

src/gpu/gl/GrGLGeometryProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLGeometryProcessor_DEFINED
 #define GrGLGeometryProcessor_DEFINED
 
@@ skipping 109 matching lines @@
 
     SkSTArray<8, SkSTArray<2, Transform, true> > fInstalledTransforms;
 
 private:
     UniformHandle fViewMatrixUniform;
     SkMatrix fViewMatrix;
     const char* fViewMatrixName;
 };
 
 class GrGLPathRendering;
+class GrGLVertexBuilder;
 /**
  * If a GL effect needs a GrGLFullShaderBuilder* object to emit vertex code, then it must inherit
  * from this class. Since paths don't have vertices, this class is only meant to be used internally
  * by skia, for special cases.
  */
 class GrGLGeometryProcessor : public GrGLPrimitiveProcessor {
 public:
     /* Any general emit code goes in the base class emitCode.  Subclasses override onEmitCode */
     void emitCode(EmitArgs&) SK_OVERRIDE;
 
     void setTransformData(const GrPrimitiveProcessor*,
                           const GrGLProgramDataManager&,
                           int index,
                           const SkTArray<const GrCoordTransform*, true>& transforms);
 
 protected:
-    const char* position() const { return "pos3"; }
-
     // Many GrGeometryProcessors do not need explicit local coords
     void emitTransforms(GrGLGPBuilder* gp,
-                        const char* position,
+                        const GrShaderVar& posVar,
                         const SkMatrix& localMatrix,
                         const TransformsIn& tin,
                         TransformsOut* tout) {
-        this->emitTransforms(gp, position, position, localMatrix, tin, tout);
+        this->emitTransforms(gp, posVar, posVar.c_str(), localMatrix, tin, tout);
     }
 
     void emitTransforms(GrGLGPBuilder*,
-                        const char* position,
+                        const GrShaderVar& posVar,
                         const char* localCoords,
                         const SkMatrix& localMatrix,
                         const TransformsIn&,
                         TransformsOut*);
 
+    struct GrGPArgs {
+        // The variable used by a GP to store its position. It can be
+        // either a vec2 or a vec3 depending on the presence of perspective.
+        GrShaderVar fPositionVar;
+    };
+
+    // Create the correct type of position variable given the CTM
+    static void SetupPosition(GrGLVertexBuilder* vsBuilder,
+                              GrGPArgs* gpArgs,
+                              const char* posName,
+                              const SkMatrix& mat,
+                              const char* matName);
+
+    static uint32_t ComputePosKey(const SkMatrix& mat) {
+        if (mat.isIdentity()) {
+            return 0x0;
+        } else if (!mat.hasPerspective()) {
+            return 0x01;
+        } else {
+            return 0x02;
+        }
+    }
+
 private:
-    virtual void onEmitCode(EmitArgs&) = 0;
+    virtual void onEmitCode(EmitArgs&, GrGPArgs*) = 0;
 
     typedef GrGLPrimitiveProcessor INHERITED;
 };
 
 class GrGLGpu;
 
 class GrGLPathProcessor : public GrGLPrimitiveProcessor {
 public:
     GrGLPathProcessor(const GrPathProcessor&, const GrBatchTracker&);
 
@@ skipping 21 matching lines @@
     virtual void didSetData(GrGLPathRendering*) {}
 
 private:
     UniformHandle fColorUniform;
     GrColor fColor;
 
     typedef GrGLPrimitiveProcessor INHERITED;
 };
 
 #endif