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 23 matching lines @@
     typedef GrGLProgramEffects::TextureSampler TextureSampler;
     typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
+    typedef GrGLProgramDataManager::VaryingHandle VaryingHandle;
 
     // Handles for program uniforms (other than per-effect uniforms)
     struct BuiltinUniformHandles {
         UniformHandle       fViewMatrixUni;
         UniformHandle       fRTAdjustmentUni;
         UniformHandle       fColorUni;
         UniformHandle       fCoverageUni;
 
         // 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 UniformInfo {
         GrGLShaderVar fVariable;
         uint32_t      fVisibility;
         GrGLint       fLocation;
     };
 
     // This uses an allocator rather than array so that the GrGLShaderVars don't move in memory
     // after they are inserted. Users of GrGLShaderBuilder get refs to the vars and ptrs to their
     // name strings. Otherwise, we'd have to hand out copies.
     typedef GrTAllocator<UniformInfo> UniformInfoArray;
 
+    struct SeparableVaryingInfo {
+        GrGLShaderVar fVariable;
+        GrGLint       fLocation;
+    };
+
+    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[],
                     const GrEffectStage* inCoverageStages[]);
 
     // Below are the results of the shader generation.
 
     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 fHasVertexShader; }
     int getTexCoordSetCount() const { SkASSERT(fProgramID); return fTexCoordSetCnt; }
     const UniformInfoArray& getUniformInfos() const { return fUniforms; }
+    const SeparableVaryingInfoArray& getSeparableVaryingInfos() const {
+        return fSeparableVaryingInfos;
+    }
 
     virtual ~GrGLShaderBuilder() {}
 
     /**
      * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
         kStandardDerivatives_GLSLFeature = 0,
 
@@ skipping 105 matching lines @@
     /** Returns a variable name that represents the position of the fragment in the FS. The position
         is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
     const char* fragmentPosition();
 
     /** Returns the variable name that holds the color of the destination pixel. This may be NULL if
         no effect advertised that it will read the destination. */
     const char* dstColor();
 
     const GrGLContextInfo& ctxInfo() const;
 
+    GrGpuGL* gpu() const { return fGpu; }
+
     /**
      * Helper for begining and ending a block in the fragment code. TODO: Make GrGLShaderBuilder
      * aware of all blocks and turn single \t's into the correct number of tabs (or spaces) so that
      * our shaders print pretty without effect writers tracking indentation.
      */
     class FSBlock {
     public:
         FSBlock(GrGLShaderBuilder* builder) : fBuilder(builder) {
             SkASSERT(NULL != builder);
             fBuilder->fsCodeAppend("\t{\n");
         }
 
         ~FSBlock() {
             fBuilder->fsCodeAppend("\t}\n");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
     GrGLShaderBuilder(GrGpuGL*, 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[],
                               int effectCnt,
                               const GrGLProgramDesc::EffectKeyProvider&,
                               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);
     void resolveProgramLocations(GrGLuint programId);
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     SkAutoTUnref<GrGLProgramEffects> fColorEffects;
     SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
     BuiltinUniformHandles            fUniformHandles;
     bool                             fHasVertexShader;
     int                              fTexCoordSetCnt;
     GrGLuint                         fProgramID;
+
+    VarArray                         fFSInputs;
+    SeparableVaryingInfoArray        fSeparableVaryingInfos;
+
 private:
     class CodeStage : SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
         bool inStageCode() const {
             this->validate();
             return NULL != fEffectStage;
         }
 
@@ skipping 103 matching lines @@
         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;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
-    VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
     UniformInfoArray                        fUniforms;
 
     SkString                                fFSCode;
 
     bool                                    fSetupFragPosition;
     bool                                    fTopLeftFragPosRead;
 
     bool                                    fHasCustomColorOutput;
     bool                                    fHasSecondaryOutput;
@@ skipping 22 matching lines @@
     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);
 
+    /** Add a separable varying input variable to the current program.
+     * A separable varying (fragment shader input) is a varying that can be used also when vertex
+     * shaders are not used. With a vertex shader, the operation is same as with other
+     * varyings. Without a vertex shader, such as with NV_path_rendering, GL APIs are used to
+     * 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);
+
     /** 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 57 matching lines @@
                                                      int effectCnt,
                                                      const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE {}
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif