Default geometry processor

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 223 matching lines @@
 
     const GrOptDrawState& optState() const { return fOptState; }
     const GrProgramDesc& desc() const { return fDesc; }
     const GrProgramDesc::KeyHeader& header() const { return fDesc.header(); }
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also mangles the name to be stage-specific if we're
     // generating stage code.
     void nameVariable(SkString* out, char prefix, const char* name);
     void setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor, GrGLSLExpr1* inputCoverage);
-    void emitAndInstallProcs(const GrOptDrawState& optState,
-                             GrGLSLExpr4* inputColor,
+    void emitAndInstallProcs(GrGLSLExpr4* inputColor,
                              GrGLSLExpr4* inputCoverage);
     void emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut);
     template <class Proc>
     void emitAndInstallProc(const Proc&,
                             int index,
                             const ProcKeyProvider&,
                             const GrGLSLExpr4& input,
                             GrGLSLExpr4* output);
 
     // these emit functions help to keep the createAndEmitProcessors template general
     void emitAndInstallProc(const GrFragmentStage&,
                             const GrProcessorKey&,
                             const char* outColor,
                             const char* inColor);
     void emitAndInstallProc(const GrGeometryProcessor&,
                             const GrProcessorKey&,
-                            const char* outColor,
-                            const char* inColor);
+                            const char* outCoverage,
+                            const char* inCoverage);
     void verify(const GrGeometryProcessor&);
     void verify(const GrFragmentProcessor&);
     void emitSamplers(const GrProcessor&,
                       GrGLProcessor::TextureSamplerArray* outSamplers,
                       GrGLInstalledProc*);
 
     // each specific program builder has a distinct transform and must override this function
     virtual void emitTransforms(const GrFragmentStage&,
                                 GrGLProcessor::TransformedCoordsArray* outCoords,
                                 GrGLInstalledFragProc*);
@@ skipping 33 matching lines @@
     public:
         AutoStageAdvance(GrGLProgramBuilder* pb) : fPB(pb) { fPB->reset(); }
         ~AutoStageAdvance() { fPB->exitStage(); }
     private:
         GrGLProgramBuilder* fPB;
     };
     void exitStage() { fOutOfStage = true; }
     void enterStage() { fOutOfStage = false; }
     int stageIndex() const { return fStageIndex; }
 
+    struct TransformVarying {
+        TransformVarying(const GrGLVarying& v, const char* uniName, const char* sourceCoords)
+            : fV(v), fUniName(uniName), fSourceCoords(sourceCoords) {}
+        GrGLVarying fV;
+        SkString fUniName;
+        SkString fSourceCoords;
+    };
+
+    void addCoordVarying(const char* name, GrGLVarying* v, const char* uniName,
+                         const char* sourceCoords) {
+        this->addVarying(name, v);
+        fCoordVaryings.push_back(TransformVarying(*v, uniName, sourceCoords));
+    }
+
+    const char* rtAdjustment() const { return "rtAdjustment"; }
+
     // number of each input/output type in a single allocation block, used by many builders
     static const int kVarsPerBlock;
 
     BuiltinUniformHandles fUniformHandles;
     GrGLVertexBuilder fVS;
     GrGLGeometryBuilder fGS;
     GrGLFragmentShaderBuilder fFS;
     bool fOutOfStage;
     int fStageIndex;
 
     GrGLInstalledGeoProc* fGeometryProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     const GrOptDrawState& fOptState;
     const GrProgramDesc& fDesc;
     GrGpuGL* fGpu;
     UniformInfoArray fUniforms;
+    SkSTArray<16, TransformVarying, true> fCoordVaryings;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 /**
  * The below structs represent processors installed in programs.  All processors can have texture
  * samplers, but only frag processors have coord transforms, hence the need for different structs
@@ skipping 41 matching lines @@
     SkSTArray<2, Transform, true>        fTransforms;
     bool                                 fLocalCoordAttrib;
 };
 
 struct GrGLInstalledFragProcs : public SkRefCnt {
     virtual ~GrGLInstalledFragProcs();
     SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
 };
 
 #endif