removing coord change matrices

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 12 matching lines @@
 
 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
 
 /**
  * Retrieves the final matrix that a transform needs to apply to its source coords.
  */
 static SkMatrix get_transform_matrix(const GrPendingFragmentStage& stage,
                                      int transformIdx,
                                      const SkMatrix& localMatrix) {
-    const GrCoordTransform& coordTransform = stage.getProcessor()->coordTransform(transformIdx);
+    const GrCoordTransform& coordTransform = stage.processor()->coordTransform(transformIdx);
     SkMatrix combined;
 
+    // We only apply the localmatrix to localcoords
     if (kLocal_GrCoordSet == coordTransform.sourceCoords()) {
-        // If we have explicit local coords or are in device coords then we shouldn't need a coord
-        // change.
-        // TODO shortly we will get rid of coord change matrices entirely, and the PrimProc will
-        // always have a local matrix, often Identity, which can be used to transform coord
-        // transforms.  Until we actually do this, we need some way for a PrimProc to say 'use my
-        // matrix' instead of the coord change mechanism.  Temporarily, we have overloaded
-        // The identity matrix to be this value, ie if a primproc has an identity matrix for a
-        // local matrix then use the coord change matrix, otherwise use the matrix on the primproc
-        if (localMatrix.isIdentity()) {
-            const SkMatrix& ccm = stage.getCoordChangeMatrix();
-            combined.setConcat(coordTransform.getMatrix(), ccm);
-        } else {
-            combined.setConcat(coordTransform.getMatrix(), localMatrix);
-        }
+        combined.setConcat(coordTransform.getMatrix(), localMatrix);
     } else {
         combined = coordTransform.getMatrix();
     }
     if (coordTransform.reverseY()) {
         // combined.postScale(1,-1);
         // combined.postTranslate(0,1);
         combined.set(SkMatrix::kMSkewY,
             combined[SkMatrix::kMPersp0] - combined[SkMatrix::kMSkewY]);
         combined.set(SkMatrix::kMScaleY,
             combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]);
@@ skipping 122 matching lines @@
     this->setFragmentData(optState);
 
     // Some of GrGLProgram subclasses need to update state here
     this->didSetData(optState.drawType());
 }
 
 void GrGLProgram::setFragmentData(const GrOptDrawState& optState) {
     int numProcessors = fFragmentProcessors->fProcs.count();
     for (int e = 0; e < numProcessors; ++e) {
         const GrPendingFragmentStage& stage = optState.getFragmentStage(e);
-        const GrProcessor& processor = *stage.getProcessor();
+        const GrProcessor& processor = *stage.processor();
         fFragmentProcessors->fProcs[e]->fGLProc->setData(fProgramDataManager, processor);
         const SkMatrix& localMatrix = optState.getPrimitiveProcessor()->localMatrix();
         this->setTransformData(stage, localMatrix, fFragmentProcessors->fProcs[e]);
         this->bindTextures(fFragmentProcessors->fProcs[e], processor);
     }
 }
 void GrGLProgram::setTransformData(const GrPendingFragmentStage& processor,
                                    const SkMatrix& localMatrix,
                                    GrGLInstalledFragProc* ip) {
     SkTArray<GrGLInstalledFragProc::Transform, true>& transforms = ip->fTransforms;
     int numTransforms = transforms.count();
-    SkASSERT(numTransforms == processor.getProcessor()->numTransforms());
+    SkASSERT(numTransforms == processor.processor()->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& matrix = get_transform_matrix(processor, t, localMatrix);
         if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
             fProgramDataManager.setSkMatrix(transforms[t].fHandle.convertToUniformHandle(), matrix);
             transforms[t].fCurrentValue = matrix;
         }
     }
 }
 
@@ skipping 86 matching lines @@
 
 void GrGLNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
 }
 
 void GrGLNvprProgram::setTransformData(const GrPendingFragmentStage& proc,
                                        const SkMatrix& localMatrix,
                                        GrGLInstalledFragProc* ip) {
     SkTArray<GrGLInstalledFragProc::Transform, true>& transforms = ip->fTransforms;
     int numTransforms = transforms.count();
-    SkASSERT(numTransforms == proc.getProcessor()->numTransforms());
+    SkASSERT(numTransforms == proc.processor()->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& transform = get_transform_matrix(proc, t, localMatrix);
         if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
             continue;
         }
         transforms[t].fCurrentValue = transform;
         const Varying& fragmentInput = fVaryings[transforms[t].fHandle.handle()];
         SkASSERT(transforms[t].fType == kVec2f_GrSLType || transforms[t].fType == kVec3f_GrSLType);
         unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3;
@@ skipping 24 matching lines @@
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
     fGpu->glPathRendering()->flushPathTexGenSettings(fTexCoordSetCnt);
 }
 
 void
 GrGLLegacyNvprProgram::setTransformData(const GrPendingFragmentStage& proc,
                                         const SkMatrix& localMatrix,
                                         GrGLInstalledFragProc* ip) {
     // We've hidden the texcoord index in the first entry of the transforms array for each effect
     int texCoordIndex = ip->fTransforms[0].fHandle.handle();
-    int numTransforms = proc.getProcessor()->numTransforms();
+    int numTransforms = proc.processor()->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         const SkMatrix& transform = get_transform_matrix(proc, t, localMatrix);
         GrGLPathRendering::PathTexGenComponents components =
                 GrGLPathRendering::kST_PathTexGenComponents;
         if (proc.isPerspectiveCoordTransform(t)) {
             components = GrGLPathRendering::kSTR_PathTexGenComponents;
         }
         fGpu->glPathRendering()->enablePathTexGen(texCoordIndex++, components, transform);
     }
 }