Move most of the transform logic into the primitive processors

src/gpu/gl/GrGLProgram.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLProgram_DEFINED
 #define GrGLProgram_DEFINED
 
 #include "builders/GrGLProgramBuilder.h"
-#include "builders/GrGLNvprProgramBuilder.h"
 #include "GrDrawState.h"
 #include "GrGLContext.h"
 #include "GrGLProgramDesc.h"
 #include "GrGLSL.h"
 #include "GrGLTexture.h"
 #include "GrGLProgramDataManager.h"
 
 #include "SkString.h"
 #include "SkXfermode.h"
 
@@ skipping 87 matching lines @@
                 const GrProgramDesc&,
                 const BuiltinUniformHandles&,
                 GrGLuint programID,
                 const UniformInfoArray&,
                 GrGLInstalledGeoProc* geometryProcessor,
                 GrGLInstalledXferProc* xferProcessor,
                 GrGLInstalledFragProcs* fragmentProcessors);
 
     // Sets the texture units for samplers.
     void initSamplerUniforms();
-    void initSamplers(GrGLInstalledProc*, int* texUnitIdx);
+    template <class Proc>
+    void initSamplers(Proc*, int* texUnitIdx);
 
     // A templated helper to loop over effects, set the transforms(via subclass) and bind textures
     void setFragmentData(const GrOptDrawState&);
-    virtual void setTransformData(const GrPendingFragmentStage&,
-                                  const SkMatrix& localMatrix,
+    virtual void setTransformData(const GrPrimitiveProcessor*,
+                                  const GrPendingFragmentStage&,
+                                  int index,
                                   GrGLInstalledFragProc*);
-    void bindTextures(const GrGLInstalledProc*, const GrProcessor&);
+    template <class Proc>
+    void bindTextures(const Proc*, const GrProcessor&);
 
     /*
      * Legacy NVPR needs a hook here to flush path tex gen settings.
      * TODO when legacy nvpr is removed, remove this call.
      */
     virtual void didSetData(GrGpu::DrawType);
 
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setRenderTargetState(const GrOptDrawState&);
     virtual void onSetRenderTargetState(const GrOptDrawState&);
@@ skipping 20 matching lines @@
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * Below are slight specializations of the program object for the different types of programs
  * The default GrGL programs consist of at the very least a vertex and fragment shader.
  * Legacy Nvpr only has a fragment shader, 1.3+ Nvpr ignores the vertex shader, but both require
  * specialized methods for setting transform data. Both types of NVPR also require setting the
  * projection matrix through a special function call
  */
-class GrGLNvprProgramBase : public GrGLProgram {
+class GrGLNvprProgram : public GrGLProgram {
 protected:
-    GrGLNvprProgramBase(GrGLGpu*,
-                        const GrProgramDesc&,
-                        const BuiltinUniformHandles&,
-                        GrGLuint programID,
-                        const UniformInfoArray&,
-                        GrGLInstalledGeoProc*,
-                        GrGLInstalledXferProc* xferProcessor,
-                        GrGLInstalledFragProcs* fragmentProcessors);
-    virtual void onSetRenderTargetState(const GrOptDrawState&);
-
-    typedef GrGLProgram INHERITED;
-};
-
-class GrGLNvprProgram : public GrGLNvprProgramBase {
-public:
-    bool hasVertexShader() const SK_OVERRIDE { return true; }
-
-private:
-    typedef GrGLNvprProgramBuilder::SeparableVaryingInfo SeparableVaryingInfo;
-    typedef GrGLNvprProgramBuilder::SeparableVaryingInfoArray SeparableVaryingInfoArray;
     GrGLNvprProgram(GrGLGpu*,
                     const GrProgramDesc&,
                     const BuiltinUniformHandles&,
                     GrGLuint programID,
                     const UniformInfoArray&,
                     GrGLInstalledGeoProc*,
                     GrGLInstalledXferProc* xferProcessor,
-                    GrGLInstalledFragProcs* fragmentProcessors,
-                    const SeparableVaryingInfoArray& separableVaryings);
+                    GrGLInstalledFragProcs* fragmentProcessors);
+
+private:
     void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrPendingFragmentStage&,
-                                  const SkMatrix& localMatrix,
+    virtual void setTransformData(const GrPrimitiveProcessor*,
+                                  const GrPendingFragmentStage&,
+                                  int index,
                                   GrGLInstalledFragProc*) SK_OVERRIDE;
-
-    struct Varying {
-        GrGLint     fLocation;
-        SkDEBUGCODE(
-            GrSLType    fType;
-        );
-    };
-    SkTArray<Varying, true> fVaryings;
+    virtual void onSetRenderTargetState(const GrOptDrawState&);
 
     friend class GrGLNvprProgramBuilder;
 
-    typedef GrGLNvprProgramBase INHERITED;
-};
-
-class GrGLLegacyNvprProgram : public GrGLNvprProgramBase {
-public:
-    bool hasVertexShader() const SK_OVERRIDE { return false; }
-
-private:
-    GrGLLegacyNvprProgram(GrGLGpu* gpu,
-                          const GrProgramDesc& desc,
-                          const BuiltinUniformHandles&,
-                          GrGLuint programID,
-                          const UniformInfoArray&,
-                          GrGLInstalledGeoProc*,
-                          GrGLInstalledXferProc* xp,
-                          GrGLInstalledFragProcs* fps,
-                          int texCoordSetCnt);
-    void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrPendingFragmentStage&,
-                                  const SkMatrix& localMatrix,
-                                  GrGLInstalledFragProc*) SK_OVERRIDE;
-
-    int fTexCoordSetCnt;
-
-    friend class GrGLLegacyNvprProgramBuilder;
-
-    typedef GrGLNvprProgramBase INHERITED;
+    typedef GrGLProgram INHERITED;
 };
 
 #endif