Implement texel buffers

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
 #include "GrProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrGLGpu.h"
+#include "GrGLBuffer.h"
 #include "GrGLPathRendering.h"
 #include "GrPathProcessor.h"
 #include "GrPipeline.h"
 #include "GrXferProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"
 #include "SkXfermode.h"
 
 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
@@ skipping 35 matching lines @@
         delete fFragmentProcessors[i];
     }
 }
 
 void GrGLProgram::abandon() {
     fProgramID = 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void append_texture_bindings(const GrProcessor& processor,
-                                    SkTArray<const GrTextureAccess*>* textureBindings) {
-    if (int numTextures = processor.numTextures()) {
-        const GrTextureAccess** bindings = textureBindings->push_back_n(numTextures);
-        int i = 0;
-        do {
-            bindings[i] = &processor.textureAccess(i);
-        } while (++i < numTextures);
-    }
-}
-
 void GrGLProgram::setData(const GrPrimitiveProcessor& primProc,
                           const GrPipeline& pipeline,
-                          SkTArray<const GrTextureAccess*>* textureBindings) {
+                          bool allowSRGBInputs) {
     this->setRenderTargetState(primProc, pipeline);
 
     // we set the textures, and uniforms for installed processors in a generic way, but subclasses
     // of GLProgram determine how to set coord transforms
+    int nextSamplerIdx = 0;
     fGeometryProcessor->setData(fProgramDataManager, primProc);
-    append_texture_bindings(primProc, textureBindings);
+    this->bindTextures(primProc, allowSRGBInputs, &nextSamplerIdx);
 
-    this->setFragmentData(primProc, pipeline, textureBindings);
+    this->setFragmentData(primProc, pipeline, allowSRGBInputs, &nextSamplerIdx);
 
     if (primProc.getPixelLocalStorageState() !=
         GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
         const GrXferProcessor& xp = pipeline.getXferProcessor();
         fXferProcessor->setData(fProgramDataManager, xp);
-        append_texture_bindings(xp, textureBindings);
+        this->bindTextures(xp, allowSRGBInputs, &nextSamplerIdx);
     }
 }
 
 void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc,
                                   const GrPipeline& pipeline,
-                                  SkTArray<const GrTextureAccess*>* textureBindings) {
+                                  bool allowSRGBInputs,
+                                  int* nextSamplerIdx) {
     int numProcessors = fFragmentProcessors.count();
     for (int i = 0; i < numProcessors; ++i) {
         const GrFragmentProcessor& processor = pipeline.getFragmentProcessor(i);
         fFragmentProcessors[i]->setData(fProgramDataManager, processor);
         this->setTransformData(primProc, processor, i);
-        append_texture_bindings(processor, textureBindings);
+        this->bindTextures(processor, allowSRGBInputs, nextSamplerIdx);
     }
 }
 void GrGLProgram::setTransformData(const GrPrimitiveProcessor& primProc,
                                    const GrFragmentProcessor& processor,
                                    int index) {
     fGeometryProcessor->setTransformData(primProc, fProgramDataManager, index,
                                          processor.coordTransforms());
 }
 
 void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
@@ skipping 19 matching lines @@
             fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
             fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
         }
     } else {
         SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
         const GrPathProcessor& pathProc = primProc.cast<GrPathProcessor>();
         fGpu->glPathRendering()->setProjectionMatrix(pathProc.viewMatrix(),
                                                      size, rt->origin());
     }
 }
+
+void GrGLProgram::bindTextures(const GrProcessor& processor, bool allowSRGBInputs,
+                               int* nextSamplerIdx) {
+    for (int i = 0; i < processor.numTextures(); ++i) {
+        const GrTextureAccess& access = processor.textureAccess(i);
+        fGpu->bindTexture((*nextSamplerIdx)++, access.getParams(),
+                          allowSRGBInputs, static_cast<GrGLTexture*>(access.getTexture()));
+    }
+    for (int i = 0; i < processor.numBuffers(); ++i) {
+        const GrBufferAccess& access = processor.bufferAccess(i);
+        fGpu->bindTexelBuffer((*nextSamplerIdx)++, access.offsetInBytes(), access.texelConfig(),
+                              static_cast<GrGLBuffer*>(access.buffer()));
+    }
+}