Implement NVPR on GLES

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 42 matching lines @@
         // We use the render target height to provide a y-down frag coord when specifying
         // origin_upper_left is not supported.
         UniformHandle       fRTHeightUni;
 
         // Uniforms for computing texture coords to do the dst-copy lookup
         UniformHandle       fDstCopyTopLeftUni;
         UniformHandle       fDstCopyScaleUni;
         UniformHandle       fDstCopySamplerUni;
     };
 
     struct GenProgramOutput {

[Kimmo Kinnunen, 2014/07/01 13:01:21]

I think this is the correct concept to represent the information gotten out of
the process of linking a shader program..

However, this class is not at the moment part of the bigger program structure..
Or, what I mean is that this is not passed to anything that would want to
configure the program in use. (eg. to use the information that (should be)
stored here)

         GenProgramOutput()
             : fColorEffects(NULL)
             , fCoverageEffects(NULL)
             , fHasVertexShader(false)
             , fTexCoordSetCnt(0)
             , fProgramID(0) {}
 
         GenProgramOutput(const GenProgramOutput& other) {
             *this = other;
         }
@@ skipping 166 matching lines @@
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
     GrGLShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
 
     GrGpuGL* gpu() const { return fGpu; }
 
     const GrGLProgramDesc& desc() const { return fDesc; }
 
-    /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
-    GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
-
     // Helper for emitEffects().
     void createAndEmitEffects(GrGLProgramEffectsBuilder*,
                               const GrEffectStage* effectStages[],
                               const EffectKey effectKeys[],
                               int effectCnt,
                               GrGLSLExpr4* inOutFSColor);
 
     // 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);
 
     virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
 
     virtual void bindProgramLocations(GrGLuint programId) const;
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     const GenProgramOutput& getOutput() const { return fOutput; }
 
     GenProgramOutput fOutput;
+    VarArray fFSInputs;
+    SkAutoTUnref<GrGLUniformManager> fUniformManager;
 
 private:
     class CodeStage : SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
         bool inStageCode() const {
             this->validate();
             return NULL != fEffectStage;
         }
@@ skipping 104 matching lines @@
     };
 
     enum {
         kNoFragPosRead_FragPosKey           = 0,  // The fragment positition will not be needed.
         kTopLeftFragPosRead_FragPosKey      = 0x1,// Read frag pos relative to top-left.
         kBottomLeftFragPosRead_FragPosKey   = 0x2,// Read frag pos relative to bottom-left.
     };
 
     const GrGLProgramDesc&                  fDesc;
     GrGpuGL*                                fGpu;
-    SkAutoTUnref<GrGLUniformManager>        fUniformManager;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
-    VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
     SkString                                fFSCode;
 
     bool                                    fSetupFragPosition;
     bool                                    fTopLeftFragPosRead;
 
     bool                                    fHasCustomColorOutput;
     bool                                    fHasSecondaryOutput;
@@ skipping 17 matching lines @@
 
     void vsCodeAppend(const char* str) { fVSCode.append(str); }
 
    /** Add a vertex attribute to the current program that is passed in from the vertex data.
        Returns false if the attribute was already there, true otherwise. */
     bool addAttribute(GrSLType type, const char* name);
 
    /** Add a varying variable to the current program to pass values between vertex and fragment
         shaders. If the last two parameters are non-NULL, they are filled in with the name
         generated. */
-    void addVarying(GrSLType type,
-                    const char* name,
-                    const char** vsOutName = NULL,
-                    const char** fsInName = NULL);
+    GrGLUniformManager::FragmentInputHandle addVarying(GrSLType type,
+                                                       const char* name,
+                                                       const char** vsOutName = NULL,
+                                                       const char** fsInName = NULL);
+
+    void addFragmentInput(const char* fsName);
 
     /** Returns a vertex attribute that represents the vertex position in the VS. This is the
         pre-matrix position and is commonly used by effects to compute texture coords via a matrix.
       */
     const GrGLShaderVar& positionAttribute() const { return *fPositionVar; }
 
     /** Returns a vertex attribute that represents the local coords in the VS. This may be the same
         as positionAttribute() or it may not be. It depends upon whether the rendering code
         specified explicit local coords or not in the GrDrawState. */
     const GrGLShaderVar& localCoordsAttribute() const { return *fLocalCoordsVar; }
@@ skipping 58 matching lines @@
                                                      const EffectKey effectKeys[],
                                                      int effectCnt,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE {}
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif