Refactor position computation to enable device space "nudge"

src/gpu/GrGeometryProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGeometryProcessor.h"
 
 #include "GrCoordTransform.h"
@@ skipping 145 matching lines @@
         GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
         pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 
 void GrGLGeometryProcessor::emitCode(EmitArgs& args) {
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
-    vsBuilder->codeAppendf("vec3 %s;", this->position());
-    this->onEmitCode(args);
-    vsBuilder->transformToNormalizedDeviceSpace(this->position());
+    GrGPArgs gpArgs;
+    this->onEmitCode(args, &gpArgs);
+    vsBuilder->transformToNormalizedDeviceSpace(gpArgs.fPositionVar);
 }
 
 void GrGLGeometryProcessor::emitTransforms(GrGLGPBuilder* pb,
-                                           const char* position,
+                                           const GrShaderVar& posVar,
                                            const char* localCoords,
                                            const SkMatrix& localMatrix,
                                            const TransformsIn& tin,
                                            TransformsOut* tout) {
     GrGLVertexBuilder* vb = pb->getVertexShaderBuilder();
     tout->push_back_n(tin.count());
     fInstalledTransforms.push_back_n(tin.count());
     for (int i = 0; i < tin.count(); i++) {
         const ProcCoords& coordTransforms = tin[i];
         fInstalledTransforms[i].push_back_n(coordTransforms.count());
@@ skipping 24 matching lines @@
             GrGLVertToFrag v(varyingType);
             pb->addVarying(strVaryingName.c_str(), &v, precision);
 
             SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
             SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords,
                                    (SkString(v.fsIn()), varyingType));
 
             // varying = matrix * coords (logically)
             if (kDevice_GrCoordSet == coordType) {
                 if (kVec2f_GrSLType == varyingType) {
-                    vb->codeAppendf("%s = (%s * %s).xy;", v.vsOut(), uniName, position);
+                    if (kVec2f_GrSLType == posVar.getType()) {
+                        vb->codeAppendf("%s = (%s * vec3(%s, 1)).xy;",
+                                        v.vsOut(), uniName, posVar.c_str());
+                    } else {
+                        vb->codeAppendf("%s = (%s * %s).xy;", v.vsOut(), uniName, posVar.c_str());

[bsalomon, 2015/01/20 15:19:51]

Is this right? It seems like we know that the vm is likely persp since the GP
emitted a vec3 pos but that the coordxform is non-persp. Don't we have to
homogenize either before or after the xform matrix multiply? Or would we never
get here because varyingType would already be vec3 because we earlier checked
the vm for persp?

+                    }
                 } else {
-                    vb->codeAppendf("%s = %s * %s;", v.vsOut(), uniName, position);
+                    if (kVec2f_GrSLType == posVar.getType()) {
+                        vb->codeAppendf("%s = %s * vec3(%s, 1);",
+                                        v.vsOut(), uniName, posVar.c_str());
+                    } else {
+                        vb->codeAppendf("%s = %s * %s;", v.vsOut(), uniName, posVar.c_str());
+                    }
                 }
             } else {
                 if (kVec2f_GrSLType == varyingType) {
                     vb->codeAppendf("%s = (%s * vec3(%s, 1)).xy;", v.vsOut(), uniName, localCoords);
                 } else {
                     vb->codeAppendf("%s = %s * vec3(%s, 1);", v.vsOut(), uniName, localCoords);
                 }
             }
         }
     }
@@ skipping 10 matching lines @@
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(procTransforms[t].fHandle.isValid());
         const SkMatrix& transform = GetTransformMatrix(primProc->localMatrix(), *transforms[t]);
         if (!procTransforms[t].fCurrentValue.cheapEqualTo(transform)) {
             pdman.setSkMatrix(procTransforms[t].fHandle.convertToUniformHandle(), transform);
             procTransforms[t].fCurrentValue = transform;
         }
     }
 }
 
+void GrGLGeometryProcessor::SetupPosition(GrGLVertexBuilder* vsBuilder,
+                                          GrGPArgs* gpArgs,
+                                          const char* posName,
+                                          const SkMatrix& mat,
+                                          const char* matName) {
+    if (mat.isIdentity()) {
+        gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
+
+        vsBuilder->codeAppendf("vec2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
+    } else if (!mat.hasPerspective()) {
+        gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
+
+        vsBuilder->codeAppendf("vec2 %s = vec2(%s * vec3(%s, 1));",
+                               gpArgs->fPositionVar.c_str(), matName, posName);
+    } else {
+        gpArgs->fPositionVar.set(kVec3f_GrSLType, "pos3");
+
+        vsBuilder->codeAppendf("vec3 %s = %s * vec3(%s, 1);",
+                               gpArgs->fPositionVar.c_str(), matName, posName);
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLPathRendering.h"
 
 struct PathBatchTracker {
     GrGPInput fInputColorType;
     GrGPInput fInputCoverageType;
     GrColor fColor;
     bool fUsesLocalCoords;
@@ skipping 268 matching lines @@
                                                           const GrGLCaps& caps) const {
     SkASSERT(caps.nvprSupport() != GrGLCaps::kNone_NvprSupport);
     if (caps.nvprSupport() == GrGLCaps::kLegacy_NvprSupport) {
         return SkNEW_ARGS(GrGLLegacyPathProcessor, (*this, bt,
                                                     caps.maxFixedFunctionTextureCoords()));
     } else {
         return SkNEW_ARGS(GrGLNormalPathProcessor, (*this, bt));
     }
 }