Initial change to create GeometryProcessor

src/gpu/gl/builders/GrGLProgramBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramBuilder_DEFINED
 #define GrGLProgramBuilder_DEFINED
 
@@ skipping 66 matching lines @@
 
     typedef GrTAllocator<SeparableVaryingInfo> SeparableVaryingInfoArray;
 
     /** Generates a shader program.
      *
      * The program implements what is specified in the stages given as input.
      * After successful generation, the builder result objects are available
      * to be used.
      * @return true if generation was successful.
      */
-    bool genProgram(const GrEffectStage* inColorStages[],
+
+    bool genProgram(const GrEffectStage* inGeometryProcessor,
+                    const GrEffectStage* inColorStages[],
                     const GrEffectStage* inCoverageStages[]);
 
-    // Below are the results of the shader generation.
-
+    GrGLProgramEffects* getGeometryProcessor() const {
+        SkASSERT(fProgramID); return fGeometryProcessor.get();
+    }
     GrGLProgramEffects* getColorEffects() const { SkASSERT(fProgramID); return fColorEffects.get(); }
     GrGLProgramEffects* getCoverageEffects() const { SkASSERT(fProgramID); return fCoverageEffects.get(); }
     const BuiltinUniformHandles& getBuiltinUniformHandles() const {
         SkASSERT(fProgramID);
         return fUniformHandles;
     }
     GrGLuint getProgramID() const { SkASSERT(fProgramID); return fProgramID; }
     bool hasVertexShader() const { SkASSERT(fProgramID); return !fFragOnly; }
     int getTexCoordSetCount() const { SkASSERT(fProgramID); return fTexCoordSetCnt; }
     const UniformInfoArray& getUniformInfos() const { return fUniforms; }
@@ skipping 56 matching lines @@
     void nameVariable(SkString* out, char prefix, const char* name);
 
     virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
 
     virtual void bindProgramLocations(GrGLuint programId);
     void resolveProgramLocations(GrGLuint programId);
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
+    SkAutoTUnref<GrGLProgramEffects> fGeometryProcessor;
     SkAutoTUnref<GrGLProgramEffects> fColorEffects;
     SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
     BuiltinUniformHandles            fUniformHandles;
     bool                             fFragOnly;
     int                              fTexCoordSetCnt;
     GrGLuint                         fProgramID;
     GrGLFragmentShaderBuilder        fFS;
     SeparableVaryingInfoArray        fSeparableVaryingInfos;
-private:
+
     class CodeStage : SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
         bool inStageCode() const {
             this->validate();
             return NULL != fEffectStage;
         }
 
         const GrEffectStage* effectStage() const {
@@ skipping 30 matching lines @@
             CodeStage*              fCodeStage;
             int                     fSavedIndex;
             const GrEffectStage*    fSavedEffectStage;
         };
     private:
         void validate() const { SkASSERT((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
         int                     fNextIndex;
         int                     fCurrentIndex;
         const GrEffectStage*    fEffectStage;
     } fCodeStage;
+private:
 
     /**
      * The base class will emit the fragment code that precedes the per-effect code and then call
      * this function. The subclass can use it to insert additional fragment code that should
      * execute before the effects' code and/or emit other shaders (e.g. geometry, vertex).
      *
      * The subclass can modify the initial color or coverage 
      */
-    virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) = 0;
+    virtual void emitCodeBeforeEffects(const GrEffectStage* geometryProcessor,
+                                       GrGLSLExpr4* color,
+                                       GrGLSLExpr4* coverage) = 0;
 
     /**
     * Adds code for effects and returns a GrGLProgramEffects* object. The caller is responsible for
     * deleting it when finished. effectStages contains the effects to add. The effect key provider 
     * is used to communicate the key each effect created in its GenKey function. inOutFSColor
     * specifies the input color to the first stage and is updated to be the output color of the
     * last stage. The handles to texture samplers for effectStage[i] are added to
     * effectSamplerHandles[i].
     */
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
@@ skipping 44 matching lines @@
      * populate the variable. The APIs can refer to the variable through the returned handle.
      */
     VaryingHandle addSeparableVarying(GrSLType type,
                                       const char* name,
                                       const char** vsOutName,
                                       const char** fsInName);
 
     GrGLVertexShaderBuilder* getVertexShaderBuilder() { return &fVS; }
 
 private:
-    virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE;
+    virtual void emitCodeBeforeEffects(const GrEffectStage* geometryProcessor,
+                                       GrGLSLExpr4* color,
+                                       GrGLSLExpr4* coverage) SK_OVERRIDE;
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
                                                      int effectCnt,
                                                      const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
+    /*
+     * These functions are temporary and will eventually operate not on effects but on
+     * geometry processors
+     */
+    void createAndEmitEffect(GrGLProgramEffectsBuilder*,
+                             const GrEffectStage* effectStage,
+                             const GrGLProgramDesc::EffectKeyProvider&,
+                             GrGLSLExpr4* inOutFSColor);
+
+    GrGLProgramEffects* createAndEmitEffect(const GrEffectStage* geometryProcessor,
+                                            const GrGLProgramDesc::EffectKeyProvider&,
+                                            GrGLSLExpr4* inOutFSColor);
+
     virtual void emitCodeAfterEffects() SK_OVERRIDE;
 
     virtual bool compileAndAttachShaders(GrGLuint programId,
                                          SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
 
     virtual void bindProgramLocations(GrGLuint programId) SK_OVERRIDE;
 
     GrGLGeometryShaderBuilder fGS;
     GrGLVertexShaderBuilder   fVS;
 
     typedef GrGLProgramBuilder INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFragmentOnlyProgramBuilder : public GrGLProgramBuilder {
 public:
     GrGLFragmentOnlyProgramBuilder(GrGpuGL*, const GrGLProgramDesc&);
 
     int addTexCoordSets(int count);
 
 private:
-    virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE {}
+    virtual void emitCodeBeforeEffects(const GrEffectStage*,
+                                       GrGLSLExpr4* color,
+                                       GrGLSLExpr4* coverage) SK_OVERRIDE {}
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
                                                      int effectCnt,
                                                      const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE {}
 
     typedef GrGLProgramBuilder INHERITED;
 };
 
 #endif