Revert of Refactor how we store and use samplers in Ganesh

src/gpu/glsl/GrGLSLProgramBuilder.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "glsl/GrGLSLProgramBuilder.h"
 
 #include "GrPipeline.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
 const int GrGLSLProgramBuilder::kVarsPerBlock = 8;
 
 GrGLSLProgramBuilder::GrGLSLProgramBuilder(const GrPipeline& pipeline,
                                            const GrPrimitiveProcessor& primProc,
                                            const GrProgramDesc& desc)
     : fVS(this)
     , fGS(this)
     , fFS(this)
     , fStageIndex(-1)
     , fPipeline(pipeline)
     , fPrimProc(primProc)
     , fDesc(desc)
     , fGeometryProcessor(nullptr)
     , fXferProcessor(nullptr)
+    , fSamplerUniforms(4)
     , fNumVertexSamplers(0)
     , fNumGeometrySamplers(0)
     , fNumFragmentSamplers(0) {
 }
 
 void GrGLSLProgramBuilder::addFeature(GrShaderFlags shaders,
                                       uint32_t featureBit,
                                       const char* extensionName) {
     if (shaders & kVertex_GrShaderFlag) {
         fVS.addFeature(featureBit, extensionName);
@@ skipping 49 matching lines @@
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
     fFS.codeAppend(openBrace.c_str());
     fVS.codeAppendf("// Primitive Processor %s\n", proc.name());
 
     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());
 
-    SkSTArray<4, SamplerHandle> texSamplers(proc.numTextures());
-    SkSTArray<2, SamplerHandle> bufferSamplers(proc.numBuffers());
+    SkSTArray<4, GrGLSLSampler> texSamplers(proc.numTextures());
+    SkSTArray<2, GrGLSLSampler> bufferSamplers(proc.numBuffers());
     this->emitSamplers(proc, &texSamplers, &bufferSamplers);
 
     GrGLSLGeometryProcessor::EmitArgs args(&fVS,
                                            &fFS,
                                            this->varyingHandler(),
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            proc,
                                            outputColor->c_str(),
                                            outputCoverage->c_str(),
-                                           texSamplers.begin(),
-                                           bufferSamplers.begin(),
+                                           texSamplers,
+                                           bufferSamplers,
                                            fCoordTransforms,
                                            &fOutCoords);
     fGeometryProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     SkDEBUGCODE(verify(proc);)
 
     fFS.codeAppend("}");
 }
@@ skipping 19 matching lines @@
     AutoStageAdvance adv(this);
     this->nameExpression(output, "output");
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
     fFS.codeAppend(openBrace.c_str());
 
     GrGLSLFragmentProcessor* fragProc = fp.createGLSLInstance();
 
-    SkSTArray<4, SamplerHandle> texSamplers(fp.numTextures());
-    SkSTArray<2, SamplerHandle> bufferSamplers(fp.numBuffers());
+    SkSTArray<4, GrGLSLSampler> texSamplers(fp.numTextures());
+    SkSTArray<2, GrGLSLSampler> bufferSamplers(fp.numBuffers());
     this->emitSamplers(fp, &texSamplers, &bufferSamplers);
 
     GrGLSLFragmentProcessor::EmitArgs args(&fFS,
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            fp,
                                            output->c_str(),
                                            input.isOnes() ? nullptr : input.c_str(),
                                            fOutCoords[index],
-                                           texSamplers.begin(),
-                                           bufferSamplers.begin());
+                                           texSamplers,
+                                           bufferSamplers);
     fragProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     SkDEBUGCODE(verify(fp);)
     fFragmentProcessors.push_back(fragProc);
 
     fFS.codeAppend("}");
 }
 
@@ skipping 14 matching lines @@
     }
 
     if (this->glslCaps()->mustDeclareFragmentShaderOutput()) {
         fFS.enableCustomOutput();
     }
 
     SkString openBrace;
     openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
     fFS.codeAppend(openBrace.c_str());
 
-    SkSTArray<4, SamplerHandle> texSamplers(xp.numTextures());
-    SkSTArray<2, SamplerHandle> bufferSamplers(xp.numBuffers());
+    SkSTArray<4, GrGLSLSampler> texSamplers(xp.numTextures());
+    SkSTArray<2, GrGLSLSampler> bufferSamplers(xp.numBuffers());
     this->emitSamplers(xp, &texSamplers, &bufferSamplers);
 
     bool usePLSDstRead = (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState);
     GrGLSLXferProcessor::EmitArgs args(&fFS,
                                        this->uniformHandler(),
                                        this->glslCaps(),
                                        xp, colorIn.c_str(),
                                        ignoresCoverage ? nullptr : coverageIn.c_str(),
                                        fFS.getPrimaryColorOutputName(),
                                        fFS.getSecondaryColorOutputName(),
-                                       texSamplers.begin(),
-                                       bufferSamplers.begin(),
+                                       texSamplers,
+                                       bufferSamplers,
                                        usePLSDstRead);
     fXferProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     SkDEBUGCODE(verify(xp);)
     fFS.codeAppend("}");
 }
 
 void GrGLSLProgramBuilder::emitSamplers(const GrProcessor& processor,
-                                        SkTArray<SamplerHandle>* outTexSamplers,
-                                        SkTArray<SamplerHandle>* outBufferSamplers) {
+                                        GrGLSLSampler::SamplerArray* outTexSamplers,
+                                        GrGLSLSampler::SamplerArray* outBufferSamplers) {
     SkString name;
     int numTextures = processor.numTextures();
     for (int t = 0; t < numTextures; ++t) {
         const GrTextureAccess& access = processor.textureAccess(t);
         GrSLType samplerType = access.getTexture()->samplerType();
         if (kSamplerExternal_GrSLType == samplerType) {
             const char* externalFeatureString = this->glslCaps()->externalTextureExtensionString();
             // We shouldn't ever create a GrGLTexture that requires external sampler type
             SkASSERT(externalFeatureString);
             this->addFeature(access.getVisibility(),
@@ skipping 22 matching lines @@
                              1 << GrGLSLShaderBuilder::kTexelBuffer_GLSLPrivateFeature,
                              extension);
         }
     }
 }
 
 void GrGLSLProgramBuilder::emitSampler(GrSLType samplerType,
                                        GrPixelConfig config,
                                        const char* name,
                                        GrShaderFlags visibility,
-                                       SkTArray<SamplerHandle>* outSamplers) {
+                                       GrGLSLSampler::SamplerArray* outSamplers) {
     if (visibility & kVertex_GrShaderFlag) {
         ++fNumVertexSamplers;
     }
     if (visibility & kGeometry_GrShaderFlag) {
         SkASSERT(this->primitiveProcessor().willUseGeoShader());
         ++fNumGeometrySamplers;
     }
     if (visibility & kFragment_GrShaderFlag) {
         ++fNumFragmentSamplers;
     }
     GrSLPrecision precision = this->glslCaps()->samplerPrecision(config, visibility);
-    SamplerHandle handle = this->uniformHandler()->addSampler(visibility,
-                                                              config,
-                                                              samplerType,
-                                                              precision,
-                                                              name);
-    outSamplers->emplace_back(handle);
+    UniformHandle u = this->uniformHandler()->addUniform(visibility, samplerType, precision, name);
+    fSamplerUniforms.push_back(u);
+    outSamplers->emplace_back(u, config);
 }
 
 void GrGLSLProgramBuilder::emitFSOutputSwizzle(bool hasSecondaryOutput) {
     // Swizzle the fragment shader outputs if necessary.
     GrSwizzle swizzle;
     swizzle.setFromKey(this->desc().header().fOutputSwizzle);
     if (swizzle != GrSwizzle::RGBA()) {
         fFS.codeAppendf("%s = %s.%s;", fFS.getPrimaryColorOutputName(),
                         fFS.getPrimaryColorOutputName(),
                         swizzle.c_str());
@@ skipping 69 matching lines @@
         this->nameVariable(&outName, '\0', baseName);
     }
     fFS.codeAppendf("vec4 %s;", outName.c_str());
     *output = outName;
 }
 
 void GrGLSLProgramBuilder::appendUniformDecls(GrShaderFlags visibility, SkString* out) const {
     this->uniformHandler()->appendUniformDecls(visibility, out);
 }
 
-const GrGLSLSampler& GrGLSLProgramBuilder::getSampler(SamplerHandle handle) const {
-    return this->uniformHandler()->getSampler(handle);
-}
-
 void GrGLSLProgramBuilder::addRTAdjustmentUniform(GrSLPrecision precision,
                                                   const char* name,
                                                   const char** outName) {
         SkASSERT(!fUniformHandles.fRTAdjustmentUni.isValid());
         fUniformHandles.fRTAdjustmentUni =
             this->uniformHandler()->addUniform(kVertex_GrShaderFlag,
                                                kVec4f_GrSLType,
                                                precision,
                                                name,
                                                outName);
@@ skipping 13 matching lines @@
         delete fFragmentProcessors[i];
     }
 }
 
 void GrGLSLProgramBuilder::finalizeShaders() {
     this->varyingHandler()->finalize();
     fVS.finalize(kVertex_GrShaderFlag);
     fFS.finalize(kFragment_GrShaderFlag);
 
 }