Cleanup of shader building system

src/gpu/gl/GrGLProgram.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLProgram_DEFINED
 #define GrGLProgram_DEFINED
 
 #include "builders/GrGLProgramBuilder.h"
+#include "builders/GrGLESNvprProgramBuilder.h"
 #include "GrDrawState.h"
 #include "GrGLContext.h"
 #include "GrGLProgramDesc.h"
 #include "GrGLSL.h"
 #include "GrGLTexture.h"
 #include "GrGLProgramDataManager.h"
 
 #include "SkString.h"
 #include "SkXfermode.h"
 
 class GrGLProcessor;
-class GrGLProgramEffects;
+class GrGLInstalledProcessors;
 class GrGLProgramBuilder;
 
 /**
  * This class manages a GPU program and records per-program information.
  * We can specify the attribute locations so that they are constant
  * across our shaders. But the driver determines the uniform locations
  * at link time. We don't need to remember the sampler uniform location
  * because we will bind a texture slot to it and never change it
  * Uniforms are program-local so we can't rely on fHWState to hold the
  * previous uniform state after a program change.
  */
 class GrGLProgram : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrGLProgram)
 
     typedef GrGLProgramBuilder::BuiltinUniformHandles BuiltinUniformHandles;
 
-    static GrGLProgram* Create(GrGpuGL* gpu,
-                               const GrGLProgramDesc& desc,
-                               const GrGeometryStage* geometryProcessor,
-                               const GrFragmentStage* colorStages[],
-                               const GrFragmentStage* coverageStages[]);
-
     virtual ~GrGLProgram();
 
     /**
      * Call to abandon GL objects owned by this program.
      */
     void abandon();
 
     const GrGLProgramDesc& getDesc() { return fDesc; }
 
     /**
      * Gets the GL program ID for this program.
      */
     GrGLuint programID() const { return fProgramID; }
 
-    bool hasVertexShader() const { return fHasVertexShader; }
+    virtual bool hasVertexShader() const = 0;
 
     /**
      * Some GL state that is relevant to programs is not stored per-program. In particular color
      * and coverage attributes can be global state. This struct is read and updated by
      * GrGLProgram::setColor and GrGLProgram::setCoverage to allow us to avoid setting this state
      * redundantly.
      */
     struct SharedGLState {
         GrColor fConstAttribColor;
         int     fConstAttribColorIndex;
@@ skipping 80 matching lines @@
      * stages come from GrGLProgramDesc::Build().
      */
     void setData(const GrOptDrawState&,
                  GrGpu::DrawType,
                  const GrGeometryStage* geometryProcessor,
                  const GrFragmentStage* colorStages[],
                  const GrFragmentStage* coverageStages[],
                  const GrDeviceCoordTexture* dstCopy, // can be NULL
                  SharedGLState*);
 
-private:
+protected:
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
+    typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
 
     GrGLProgram(GrGpuGL*,
                 const GrGLProgramDesc&,
-                const GrGLProgramBuilder&);
+                const BuiltinUniformHandles&,
+                GrGLuint programID,
+                const UniformInfoArray&,
+                GrGLInstalledProcessors* geometryProcessor,
+                GrGLInstalledProcessors* colorProcessors,
+                GrGLInstalledProcessors* coverageProcessors);
 
     // Sets the texture units for samplers.
     void initSamplerUniforms();
+    void initSamplers(GrGLInstalledProcessors* processors, int* texUnitIdx);
 
     // Helper for setData(). Makes GL calls to specify the initial color when there is not
     // per-vertex colors.
     void setColor(const GrOptDrawState&, GrColor color, SharedGLState*);
 
     // Helper for setData(). Makes GL calls to specify the initial coverage when there is not
     // per-vertex coverages.
     void setCoverage(const GrOptDrawState&, GrColor coverage, SharedGLState*);
 
+    virtual void postSetData(GrGpu::DrawType) = 0;
+
+    // A templated helper to loop over effects, set the transforms(via subclass) and bind textures
+    template <class ProcessorStage>
+    void setData(const ProcessorStage* effectStages[],
+                 GrGLInstalledProcessors* installedProcessors) {
+        int numEffects = installedProcessors->fGLProcessors.count();
+        SkASSERT(numEffects == installedProcessors->fTransforms.count());
+        SkASSERT(numEffects == installedProcessors->fSamplers.count());
+        for (int e = 0; e < numEffects; ++e) {
+            const GrProcessor& effect = *effectStages[e]->getProcessor();
+            installedProcessors->fGLProcessors[e]->setData(fProgramDataManager, effect);
+            this->setTransformData(*effectStages[e], e, installedProcessors);
+            this->bindTextures(installedProcessors, effect, e);
+        }
+    }
+    virtual void setTransformData(const GrProcessorStage& effectStage,
+                                  int effectIdx,
+                                  GrGLInstalledProcessors* pe) = 0;
+    void bindTextures(const GrGLInstalledProcessors*, const GrProcessor&, int effectIdx);
+
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType, const GrOptDrawState&);
+    virtual void setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
+                                                  const GrOptDrawState& optState,
+                                                  const GrRenderTarget*,
+                                                  const SkISize&) = 0;
 
     // these reflect the current values of uniforms (GL uniform values travel with program)
-    MatrixState                         fMatrixState;
-    GrColor                             fColor;
-    GrColor                             fCoverage;
-    int                                 fDstCopyTexUnit;
+    MatrixState                          fMatrixState;
+    GrColor                              fColor;
+    GrColor                              fCoverage;
+    int                                  fDstCopyTexUnit;
+    BuiltinUniformHandles                fBuiltinUniformHandles;
+    GrGLuint                             fProgramID;
 
-    BuiltinUniformHandles               fBuiltinUniformHandles;
-    SkAutoTUnref<GrGLProgramEffects>    fGeometryProcessor;
-    SkAutoTUnref<GrGLProgramEffects>    fColorEffects;
-    SkAutoTUnref<GrGLProgramEffects>    fCoverageEffects;
-    GrGLuint                            fProgramID;
-    bool                                fHasVertexShader;
-    int                                 fTexCoordSetCnt;
+    // the installed effects
+    SkAutoTUnref<GrGLInstalledProcessors>     fGeometryProcessor;

[bsalomon, 2014/09/29 15:43:19]

Let's either line up all the members or none of them

[joshua.litt, 2014/09/29 21:05:22]

done

+    SkAutoTUnref<GrGLInstalledProcessors>     fColorEffects;
+    SkAutoTUnref<GrGLInstalledProcessors>     fCoverageEffects;
 
-    GrGLProgramDesc                     fDesc;
-    GrGpuGL*                            fGpu;
-
-    GrGLProgramDataManager              fProgramDataManager;
+    GrGLProgramDesc                      fDesc;
+    GrGpuGL*                             fGpu;
+    GrGLProgramDataManager               fProgramDataManager;
 
     typedef SkRefCnt INHERITED;
 };
 
+/*
+ * Below are slight specializations of the program object for the different types of programs Skia
+ * supports.  Skia programs consist of at the very least a vertex and fragment shader.  Old school
+ * Nvpr only has a fragment shader, NvprES ignores the vertex shader, but both require specialized

[bsalomon, 2014/09/29 15:43:19]

Can we say NVPR 1.3+ rather than NvprES since the desktop drivers will support
the updated extension?

For class names we could have NVPR and LegacyNVPR (since the latter is to be
deleted).

[joshua.litt, 2014/09/29 21:05:22]

done

+ * methods for setting transform data.
+ */
+class GrGLSkiaProgram : public GrGLProgram {
+public:
+    virtual bool hasVertexShader() const SK_OVERRIDE { return true; }
+
+private:
+    GrGLSkiaProgram(GrGpuGL*,
+                    const GrGLProgramDesc&,
+                    const BuiltinUniformHandles&,
+                    GrGLuint programID,
+                    const UniformInfoArray&,
+                    GrGLInstalledProcessors* geometryProcessor,
+                    GrGLInstalledProcessors* colorProcessors,
+                    GrGLInstalledProcessors* coverageProcessors);
+
+    virtual void postSetData(GrGpu::DrawType) SK_OVERRIDE;
+    virtual void setTransformData(const GrProcessorStage&,
+                                  int effectIdx,
+                                  GrGLInstalledProcessors*) SK_OVERRIDE;
+    virtual void setMatrixAndRenderTargetHeight(GrGpu::DrawType,
+                                                  const GrOptDrawState&,
+                                                  const GrRenderTarget*,
+                                                  const SkISize&) SK_OVERRIDE;
+
+    friend class GrGLSkiaProgramBuilder;
+
+    typedef GrGLProgram INHERITED;
+};
+
+/*
+ * Both types of NVPR require setting the projection matrix through a special function call
+ */
+class GrGLNvprProgramBase : public GrGLProgram {
+protected:
+    GrGLNvprProgramBase(GrGpuGL*,
+                        const GrGLProgramDesc&,
+                        const BuiltinUniformHandles&,
+                        GrGLuint programID,
+                        const UniformInfoArray&,
+                        GrGLInstalledProcessors* colorProcessors,
+                        GrGLInstalledProcessors* coverageProcessors);
+    virtual void setMatrixAndRenderTargetHeight(GrGpu::DrawType,
+                                                  const GrOptDrawState&,
+                                                  const GrRenderTarget*,
+                                                  const SkISize&);
+
+    typedef GrGLProgram INHERITED;
+};
+
+class GrGLESNvprProgram : public GrGLNvprProgramBase {
+public:
+      virtual bool hasVertexShader() const SK_OVERRIDE { return true; }
+
+private:
+    typedef GrGLESNvprProgramBuilder::SeparableVaryingInfo SeparableVaryingInfo;
+    typedef GrGLESNvprProgramBuilder::SeparableVaryingInfoArray SeparableVaryingInfoArray;
+    GrGLESNvprProgram(GrGpuGL*,
+                      const GrGLProgramDesc&,
+                      const BuiltinUniformHandles&,
+                      GrGLuint programID,
+                      const UniformInfoArray&,
+                      GrGLInstalledProcessors* colorProcessors,
+                      GrGLInstalledProcessors* coverageProcessors,
+                      const SeparableVaryingInfoArray& separableVaryings);
+    virtual void postSetData(GrGpu::DrawType) SK_OVERRIDE;
+    virtual void setTransformData(const GrProcessorStage&,
+                                  int effectIdx,
+                                  GrGLInstalledProcessors*) SK_OVERRIDE;
+
+    struct Varying {
+        GrGLint     fLocation;
+        SkDEBUGCODE(
+            GrSLType    fType;
+        );
+    };
+    SkTArray<Varying, true> fVaryings;
+
+    friend class GrGLESNvprProgramBuilder;
+
+    typedef GrGLNvprProgramBase INHERITED;
+};
+
+class GrGLNvprProgram : public GrGLNvprProgramBase {
+public:
+    virtual bool hasVertexShader() const SK_OVERRIDE { return false; }
+
+private:
+    GrGLNvprProgram(GrGpuGL* gpu,
+                    const GrGLProgramDesc& desc,
+                    const BuiltinUniformHandles&,
+                    GrGLuint programID,
+                    const UniformInfoArray&,
+                    GrGLInstalledProcessors* colorProcessors,
+                    GrGLInstalledProcessors* coverageProcessors,
+                    int texCoordSetCnt);
+    virtual void postSetData(GrGpu::DrawType) SK_OVERRIDE;
+    virtual void setTransformData(const GrProcessorStage&,
+                                  int effectIdx,
+                                  GrGLInstalledProcessors*) SK_OVERRIDE;
+
+    int fTexCoordSetCnt;
+
+    friend class GrGLNvprProgramBuilder;
+
+    typedef GrGLNvprProgramBase INHERITED;
+};
+
 #endif