Implement texel buffers

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"
@@ skipping 80 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, GrGLSLSampler> texSamplers(proc.numTextures());
-    this->emitSamplers(proc, &texSamplers);
+    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,
+                                           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 20 matching lines @@
     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, GrGLSLSampler> texSamplers(fp.numTextures());
-    this->emitSamplers(fp, &texSamplers);
+    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);
+                                           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 15 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, GrGLSLSampler> texSamplers(xp.numTextures());
-    this->emitSamplers(xp, &texSamplers);
+    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,
+                                       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,
-                                        GrGLSLSampler::SamplerArray* outTexSamplers) {
+                                        GrGLSLSampler::SamplerArray* outTexSamplers,
+                                        GrGLSLSampler::SamplerArray* outBufferSamplers) {
+    SkString name;
     int numTextures = processor.numTextures();
-    UniformHandle* localSamplerUniforms = fSamplerUniforms.push_back_n(numTextures);
-    SkString name;
     for (int t = 0; t < numTextures; ++t) {
         const GrTextureAccess& access = processor.textureAccess(t);
-        GrShaderFlags visibility = access.getVisibility();
-        if (visibility & kVertex_GrShaderFlag) {
-            ++fNumVertexSamplers;
-        }
-        if (visibility & kGeometry_GrShaderFlag) {
-            SkASSERT(this->primitiveProcessor().willUseGeoShader());
-            ++fNumGeometrySamplers;
-        }
-        if (visibility & kFragment_GrShaderFlag) {
-            ++fNumFragmentSamplers;
-        }
         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(visibility,
+            this->addFeature(access.getVisibility(),
                              1 << GrGLSLShaderBuilder::kExternalTexture_GLSLPrivateFeature,
                              externalFeatureString);
         }
-        GrSLPrecision precision = this->glslCaps()->samplerPrecision(access.getTexture()->config(),
-                                                                     visibility);
-        name.printf("Sampler%d", t);
-        localSamplerUniforms[t] = this->uniformHandler()->addUniform(visibility,
-                                                                     samplerType,
-                                                                     precision,
-                                                                     name.c_str());
-        outTexSamplers->emplace_back(localSamplerUniforms[t], access.getTexture()->config());
+        name.printf("TextureSampler%d", t);
+        this->emitSampler(samplerType, access.getTexture()->config(),
+                          name.c_str(), access.getVisibility(), outTexSamplers);
+    }
+
+    if (int numBuffers = processor.numBuffers()) {
+        SkASSERT(this->glslCaps()->texelBufferSupport());
+        GrShaderFlags texelBufferVisibility = kNone_GrShaderFlags;
+
+        for (int b = 0; b < numBuffers; ++b) {
+            const GrBufferAccess& access = processor.bufferAccess(b);
+            name.printf("BufferSampler%d", b);
+            this->emitSampler(kSamplerBuffer_GrSLType, access.texelConfig(), name.c_str(),
+                              access.visibility(), outBufferSamplers);
+            texelBufferVisibility |= access.visibility();
+        }
+
+        if (const char* extension = this->glslCaps()->texelBufferExtensionString()) {
+            this->addFeature(texelBufferVisibility,
+                             1 << GrGLSLShaderBuilder::kTexelBuffer_GLSLPrivateFeature,
+                             extension);
+        }
     }
 }
 
+void GrGLSLProgramBuilder::emitSampler(GrSLType samplerType,
+                                       GrPixelConfig config,
+                                       const char* name,
+                                       GrShaderFlags visibility,
+                                       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);
+    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());
         if (hasSecondaryOutput) {
             fFS.codeAppendf("%s = %s.%s;", fFS.getSecondaryColorOutputName(),
@@ skipping 100 matching lines @@
         delete fFragmentProcessors[i];
     }
 }
 
 void GrGLSLProgramBuilder::finalizeShaders() {
     this->varyingHandler()->finalize();
     fVS.finalize(kVertex_GrShaderFlag);
     fFS.finalize(kFragment_GrShaderFlag);
 
 }