Refactor how we store and use samplers in Ganesh

src/gpu/glsl/GrGLSLUniformHandler.h

Index: src/gpu/glsl/GrGLSLUniformHandler.h
diff --git a/src/gpu/glsl/GrGLSLUniformHandler.h b/src/gpu/glsl/GrGLSLUniformHandler.h
index a2f70532adc2948de8641b18b632a727a026e844..99f4b1111fb14ff2bc40aac2e7cfb41270c3d417 100644
--- a/src/gpu/glsl/GrGLSLUniformHandler.h
+++ b/src/gpu/glsl/GrGLSLUniformHandler.h
@@ -12,12 +12,14 @@
 #include "GrGLSLShaderVar.h"
 
 class GrGLSLProgramBuilder;
+class GrGLSLSampler;
 
 class GrGLSLUniformHandler {
 public:
     virtual ~GrGLSLUniformHandler() {}
 
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
+    typedef GrGLSLProgramDataManager::UniformHandle SamplerHandle;
 
     /** Add a uniform variable to the current program, that has visibility in one or more shaders.
         visibility is a bitfield of GrShaderFlag values indicating from which shaders the uniform
@@ -30,6 +32,7 @@ public:
                              GrSLPrecision precision,
                              const char* name,
                              const char** outName = nullptr) {
+        SkASSERT(!GrSLTypeIsSamplerType(type));
         return this->addUniformArray(visibility, type, precision, name, 0, outName);
     }
 
@@ -39,6 +42,7 @@ public:
                                   const char* name,
                                   int arrayCount,
                                   const char** outName = nullptr) {
+        SkASSERT(!GrSLTypeIsSamplerType(type));
         return this->internalAddUniformArray(visibility, type, precision, name, true, arrayCount,
                                              outName);
     }
@@ -49,6 +53,9 @@ public:
      * Shortcut for getUniformVariable(u).c_str()
      */
     virtual const char* getUniformCStr(UniformHandle u) const = 0;
+
+    virtual const GrGLSLSampler& getSampler(SamplerHandle handle) const = 0;

[bsalomon, 2016/04/14 01:40:16]

It seems a bit unfortunate to make every processor jump through this function to
insert a texture lookup. From a FP writer's perspective it seems like just
another piece of odd boilerplate code to add to my implementation. Is there a
way around that? Could we pass the processors an opaque type that has the
GrGLSLSampler and the handle under the hood? Or have the builder do this lookup?
Or...

[egdaniel, 2016/04/14 03:11:50]

Yeah I think it would be fine for appendTexLookup to just take a SamplerHandle
instead of a GrGLSLSampler. We'll do the get the sampler inside of
appendTexLookup.

I hesitate making another opaque type to hold the handle/sampler under the hood.
That is basically what the current version of GrGLSLSampler is and to me it
added more confusion when trying to figure out what all the various sampler
objects did (GrGLSLSampler, Sampler Uniforms of Uniformhandler, the fSamplers
stored on programbuilder and program). I think its cleaner to just have the
GrGLSLSamplers and handles to them.

+
 protected:
     explicit GrGLSLUniformHandler(GrGLSLProgramBuilder* program) : fProgramBuilder(program) {}
 
@@ -56,6 +63,22 @@ protected:
     GrGLSLProgramBuilder* fProgramBuilder;
 
 private:
+    virtual int numSamplers() const = 0;
+
+    SamplerHandle addSampler(uint32_t visibility,
+                             GrPixelConfig config,
+                             GrSLType type,
+                             GrSLPrecision precision,
+                             const char* name) {
+        this->internalAddSampler(visibility, config, type, precision, name);
+    }
+
+    virtual SamplerHandle internalAddSampler(uint32_t visibility,
+                                             GrPixelConfig config,
+                                             GrSLType type,
+                                             GrSLPrecision precision,
+                                             const char* name) = 0;
+
     virtual UniformHandle internalAddUniformArray(uint32_t visibility,
                                                   GrSLType type,
                                                   GrSLPrecision precision,
@@ -64,6 +87,7 @@ private:
                                                   int arrayCount,
                                                   const char** outName) = 0;
 
+
     virtual void appendUniformDecls(GrShaderFlags visibility, SkString*) const = 0;
 
     friend class GrGLSLProgramBuilder;