Move VertexBuilder to a GrGLFullShaderBuilder subclass

src/gpu/gl/GrGLEffectArray.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 GrGLEffectArray_DEFINED
 #define GrGLEffectArray_DEFINED
 
 #include "GrBackendEffectFactory.h"
 #include "GrTexture.h"
 #include "GrTextureAccess.h"
 #include "GrGLUniformManager.h"
 
 class GrEffectStage;
 class GrGLEffectArrayBuilder;
+class GrGLVertexEffectArrayBuilder;
 class GrGLShaderBuilder;
+class GrGLFullShaderBuilder;
 
 /**
  * This class encapsulates an array of GrGLEffects and their supporting data (coord transforms
  * and textures). It is built with GrGLEffectArrayBuilder, then used to manage the necessary GL
  * state and shader uniforms.
  */
 class GrGLEffectArray {
 public:
     typedef GrBackendEffectFactory::EffectKey EffectKey;
     typedef GrGLUniformManager::UniformHandle UniformHandle;
 
     /**
      * These methods generate different portions of an effect's final key.
      */
     static EffectKey GenAttribKey(const GrDrawEffect&);
     static EffectKey GenTransformKey(const GrDrawEffect&);
     static EffectKey GenTextureKey(const GrDrawEffect&, const GrGLCaps&);
 
-    ~GrGLEffectArray() { fGLEffects.deleteAll(); }
+    virtual ~GrGLEffectArray() { fGLEffects.deleteAll(); }
 
     /**
      * Assigns a texture unit to each sampler. It starts on *texUnitIdx and writes the next
      * available unit to *texUnitIdx when it returns.
      */
     void initSamplers(const GrGLUniformManager&, int* texUnitIdx);
 
     /**
      * Calls setData() on each effect, and sets their transformation matrices and texture bindings.
      */
-    void setData(GrGpuGL*,
-                 const GrGLUniformManager&,
-                 const GrEffectStage* effectStages[]);
+    virtual void setData(GrGpuGL*,
+                         const GrGLUniformManager&,
+                         const GrEffectStage* effectStages[]) = 0;
 
     /**
      * Passed to GrGLEffects so they can add transformed coordinates to their shader code.
      */
     class TransformedCoords {
     public:
         TransformedCoords(const char* name, GrSLType type, const char* vsName)
             : fName(name), fType(type), fVSName(vsName) {
         }
 
@@ skipping 29 matching lines @@
         const char* swizzle() const { return fSwizzle; }
 
     private:
         UniformHandle fSamplerUniform;
         uint32_t      fConfigComponentMask;
         char          fSwizzle[5];
     };
 
     typedef SkTArray<TextureSampler> TextureSamplerArray;
 
-private:
+protected:
     friend class GrGLEffectArrayBuilder;
 
-    GrGLEffectArray(int reserveCount, bool explicitLocalCoords)
-        : fTransforms(reserveCount)
-        , fSamplers(reserveCount)
+    GrGLEffectArray(int reserveCount) : fSamplers(reserveCount) {}
+
+    /**
+     * Helper for setData(). Binds all the textures for an effect.
+     */
+    void bindTextures(GrGpuGL*, const GrEffectRef&, int effectIdx);
+
+    struct Sampler {
+        SkDEBUGCODE(Sampler() : fTextureUnit(-1) {})
+        UniformHandle fUniform;
+        int           fTextureUnit;
+    };
+
+    SkTDArray<GrGLEffect*>                 fGLEffects;
+    SkTArray<SkSTArray<4, Sampler, true> > fSamplers;
+};
+
+/**
+ * This is a GrGLEffectArray implementation that does coord transforms with the vertex shader.
+ */
+class GrGLVertexEffectArray : public GrGLEffectArray {
+public:
+    /**
+     * Calls setData() on each effect, and sets their transformation matrices and texture bindings.
+     */
+    virtual void setData(GrGpuGL*,
+                         const GrGLUniformManager&,
+                         const GrEffectStage* effectStages[]) SK_OVERRIDE;
+
+private:
+    friend class GrGLVertexEffectArrayBuilder;
+
+    GrGLVertexEffectArray(int reserveCount, bool explicitLocalCoords)
+        : INHERITED(reserveCount)
+        , fTransforms(reserveCount)
         , fHasExplicitLocalCoords(explicitLocalCoords) {
     }
 
     /**
      * Helper for setData(). Sets all the transform matrices for an effect.
      */
     void setTransformData(const GrGLUniformManager&, const GrDrawEffect&, int effectIdx);
 
-    /**
-     * Helper for setData(). Binds all the textures for an effect.
-     */
-    void bindTextures(GrGpuGL*, const GrEffectRef&, int effectIdx);
-
     struct Transform {
         Transform() { fCurrentValue = SkMatrix::InvalidMatrix(); }
         UniformHandle fHandle;
         GrSLType      fType;
         SkMatrix      fCurrentValue;
     };
 
-    struct Sampler {
-        SkDEBUGCODE(Sampler() : fTextureUnit(-1) {})
-        UniformHandle fUniform;
-        int           fTextureUnit;
-    };
+    SkTArray<SkSTArray<2, Transform, true> > fTransforms;
+    bool                                     fHasExplicitLocalCoords;
 
-    SkTDArray<GrGLEffect*>                   fGLEffects;
-    SkTArray<SkSTArray<2, Transform, true> > fTransforms;
-    SkTArray<SkSTArray<4, Sampler, true> >   fSamplers;
-    bool                                     fHasExplicitLocalCoords;
+    typedef GrGLEffectArray INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * This class is used to construct a GrGLEffectArray.
  */
 class GrGLEffectArrayBuilder {
 public:
-    GrGLEffectArrayBuilder(GrGLShaderBuilder* builder, int reserveCount);
-
     /**
      * Emits the effect's shader code, and stores the necessary uniforms internally.
      */
-    void emitEffect(const GrEffectStage&,
-                    GrGLEffectArray::EffectKey,
-                    const char* outColor,
-                    const char* inColor,
-                    int stageIndex);
+    virtual void emitEffect(const GrEffectStage&,
+                            GrGLEffectArray::EffectKey,
+                            const char* outColor,
+                            const char* inColor,
+                            int stageIndex) = 0;
+
+protected:
+    /**
+     * Helper for emitEffect(). Emits uniforms for an effect's texture accesses and appends the
+     * necessary data to the TextureSamplerArray* object so effects can add texture lookups.
+     */
+    static void emitSamplers(GrGLShaderBuilder*,
+                             GrGLEffectArray*,
+                             const GrEffectRef&,
+                             GrGLEffectArray::TextureSamplerArray*);
+};
+
+/**
+ * This class is used by GrGLFullShaderBuilder to construct a GrGLVertexEffectArray.
+ */
+class GrGLVertexEffectArrayBuilder : public GrGLEffectArrayBuilder {
+public:
+    GrGLVertexEffectArrayBuilder(GrGLFullShaderBuilder*, int reserveCount);
+
+    virtual void emitEffect(const GrEffectStage&,
+                            GrGLEffectArray::EffectKey,
+                            const char* outColor,
+                            const char* inColor,
+                            int stageIndex) SK_OVERRIDE;
 
     /**
      * Finalizes the building process and returns the effect array. After this call, the builder
      * becomes invalid.
      */
     GrGLEffectArray* finish() { return fEffectArray.detach(); }
 
 private:
     /**
      * Helper for emitEffect(). Emits any attributes an effect might have.
      */
     void emitAttributes(const GrEffectStage&);
 
     /**
      * Helper for emitEffect(). Emits code to implement an effect's coord transforms in the VS.
      * Varyings are added as an outputs of the VS and inputs to the FS. The varyings may be either a
      * vec2f or vec3f depending upon whether perspective interpolation is required or not. The names
      * of the varyings in the VS and FS as well their types are appended to the
      * TransformedCoordsArray* object, which is in turn passed to the effect's emitCode() function.
      */
     void emitTransforms(const GrEffectRef&,
                         GrGLEffectArray::EffectKey,
                         GrGLEffectArray::TransformedCoordsArray*);
 
-    /**
-     * Helper for emitEffect(). Emits uniforms for an effect's texture accesses. The uniform info
-     * as well as texture access parameters are appended to the TextureSamplerArray* object, which
-     * is in turn passed to the effect's emitCode() function.
-     */
-    void emitSamplers(const GrEffectRef&,
-                      GrGLEffectArray::TextureSamplerArray*);
+    GrGLFullShaderBuilder*               fBuilder;
+    SkAutoTDelete<GrGLVertexEffectArray> fEffectArray;
 
-    GrGLShaderBuilder*             fBuilder;
-    SkAutoTDelete<GrGLEffectArray> fEffectArray;
+    typedef GrGLEffectArrayBuilder INHERITED;
 };
 
 #endif