Add addFragPosUniform to GrGLrogramBuilder

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 50 matching lines @@
                              const char** outName = nullptr) {
         return this->addUniformArray(visibility, type, precision, name, 0, outName);
     }
 
     virtual UniformHandle addUniformArray(
         uint32_t visibility,
         GrSLType type,
         GrSLPrecision precision,
         const char* name,
         int arrayCount,
-        const char** outName = nullptr) = 0;
+        const char** outName = nullptr) {
+        return this->internalAddUniformArray(visibility, type, precision, name, true, arrayCount,
+                                             outName);
+    }
+
 
     virtual const GrGLSLShaderVar& getUniformVariable(UniformHandle u) const = 0;
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     virtual const char* getUniformCStr(UniformHandle u) const = 0;
 
     virtual const GrGLContextInfo& ctxInfo() const = 0;
 
     virtual const GrGLSLCaps* glslCaps() const = 0;
 
     virtual GrGLGpu* gpu() const = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
+private:
+    virtual UniformHandle internalAddUniformArray(
+        uint32_t visibility,
+        GrSLType type,
+        GrSLPrecision precision,
+        const char* name,
+        bool mangleName,
+        int arrayCount,
+        const char** outName) = 0;
 };
 
 // TODO move this into GrGLGPBuilder and move them both out of this file
 class GrGLVarying {
 public:
     bool vsVarying() const { return kVertToFrag_Varying == fVarying ||
                                     kVertToGeo_Varying == fVarying; }
     bool fsVarying() const { return kVertToFrag_Varying == fVarying ||
                                     kGeoToFrag_Varying == fVarying; }
     const char* vsOut() const { return fVsOut; }
@@ skipping 133 matching lines @@
     typedef GrGpu::DrawArgs DrawArgs;
     /** 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.
      */
     static GrGLProgram* CreateProgram(const DrawArgs&, GrGLGpu*);
 
-    UniformHandle addUniformArray(uint32_t visibility,
-                                  GrSLType type,
-                                  GrSLPrecision precision,
-                                  const char* name,
-                                  int arrayCount,
-                                  const char** outName) override;
-
     const GrGLSLShaderVar& getUniformVariable(UniformHandle u) const override {
         return fUniforms[u.toIndex()].fVariable;
     }
 
     const char* getUniformCStr(UniformHandle u) const override {
         return this->getUniformVariable(u).c_str();
     }
 
     const GrGLContextInfo& ctxInfo() const override;
 
@@ skipping 32 matching lines @@
     typedef GrGLProgramDataManager::SeparableVaryingInfo SeparableVaryingInfo;
     typedef GrGLProgramDataManager::SeparableVaryingInfoArray SeparableVaryingInfoArray;
 
     GrGLProgramBuilder(GrGLGpu*, const DrawArgs&);
 
     const GrPrimitiveProcessor& primitiveProcessor() const { return *fArgs.fPrimitiveProcessor; }
     const GrPipeline& pipeline() const { return *fArgs.fPipeline; }
     const GrProgramDesc& desc() const { return *fArgs.fDesc; }
     const GrProgramDesc::KeyHeader& header() const { return fArgs.fDesc->header(); }
 
+    UniformHandle internalAddUniformArray(uint32_t visibility,
+                                          GrSLType type,
+                                          GrSLPrecision precision,
+                                          const char* name,
+                                          bool mangleName,
+                                          int arrayCount,
+                                          const char** outName) override;
+
+    // Used to add a uniform for frag position without mangling the name of the uniform inside of a
+    // stage.
+    UniformHandle addFragPosUniform(uint32_t visibility,
+                                    GrSLType type,
+                                    GrSLPrecision precision,
+                                    const char* name,
+                                    const char** outName) {
+        SkDebugf("in my frag pos thing\n");
+        return this->internalAddUniformArray(visibility, type, precision, name, false, 0, outName);
+    }
+
     // 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);
+    // char (unless the prefix is '\0'). It also will mangle the name to be stage-specific unless
+    // explicitly asked not to.
+    void nameVariable(SkString* out, char prefix, const char* name, bool mangle = true);
     // Generates a possibly mangled name for a stage variable and writes it to the fragment shader.
     // If GrGLSLExpr4 has a valid name then it will use that instead
     void nameExpression(GrGLSLExpr4*, const char* baseName);
     bool emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage);
     void emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut);
     void emitAndInstallProc(const GrFragmentProcessor&,
                             int index,
                             const GrGLSLExpr4& input,
                             GrGLSLExpr4* output);
 
@@ skipping 34 matching lines @@
 
     // Subclasses create different programs
     virtual GrGLProgram* createProgram(GrGLuint programID);
 
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     // reset is called by program creator between each processor's emit code.  It increments the
     // stage offset for variable name mangling, and also ensures verfication variables in the
     // fragment shader are cleared.
     void reset() {
-        this->enterStage();
         this->addStage();
         fFS.reset();
     }
     void addStage() { fStageIndex++; }
 
-    // This simple class exits the stage and then restores the stage when it goes out of scope
-    class AutoStageRestore {
-    public:
-        AutoStageRestore(GrGLProgramBuilder* pb)
-            : fPB(pb), fOutOfStage(pb->fOutOfStage) { pb->exitStage(); }
-        ~AutoStageRestore() { fPB->fOutOfStage = fOutOfStage; }
-    private:
-        GrGLProgramBuilder* fPB;
-        bool fOutOfStage;
-    };
     class AutoStageAdvance {
     public:
         AutoStageAdvance(GrGLProgramBuilder* pb)
             : fPB(pb) {
             fPB->reset();
             // Each output to the fragment processor gets its own code section
             fPB->fFS.nextStage();
         }
-        ~AutoStageAdvance() { fPB->exitStage(); }
+        ~AutoStageAdvance() {}
     private:
         GrGLProgramBuilder* fPB;
     };
-    void exitStage() { fOutOfStage = true; }
-    void enterStage() { fOutOfStage = false; }
     int stageIndex() const { return fStageIndex; }
 
     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;
     GrGLInstalledXferProc* fXferProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     const DrawArgs& fArgs;
     GrGLGpu* fGpu;
     UniformInfoArray fUniforms;
     GrGLPrimitiveProcessor::TransformsIn fCoordTransforms;
     GrGLPrimitiveProcessor::TransformsOut fOutCoords;
     SkTArray<UniformHandle> fSamplerUniforms;
     SeparableVaryingInfoArray fSeparableVaryingInfos;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 #endif