Implement GL support for buffer textures

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLGLSL.h"
 #include "GrGLStencilAttachment.h"
@@ skipping 564 matching lines @@
             // This combination is not supported.
             return nullptr;
         }
         if (!this->glCaps().glslCaps()->externalTextureSupport()) {
             return nullptr;
         }
     } else  if (GR_GL_TEXTURE_RECTANGLE == idDesc.fInfo.fTarget) {
         if (!this->glCaps().rectangleTextureSupport()) {
             return nullptr;
         }
+    } else if (GR_GL_TEXTURE_BUFFER == idDesc.fInfo.fTarget) {
+        if (!this->glCaps().glslCaps()->bufferTextureSupport()) {
+            SkDEBUGFAIL("Buffer textures are not supported.");
+            return nullptr;
+        }
+        if (renderTarget) {
+            SkDEBUGFAIL("Rendering to a buffer texture is not supported.");
+            return nullptr;
+        }
+        if (0 != desc.fHeight) {
+            // This texture is just a 1-dimensional window into a buffer object. It has no height
+            // and its GPU memory size is effectively zero, because the actual memory is attributed
+            // to the buffer object itself.
+            SkDEBUGFAIL("Buffer textures must have a height of 0.");
+            return nullptr;
+        }
+        if (0 != desc.fSampleCnt) {
+            SkDEBUGFAIL("Multisampled buffer textures are not supported.");
+            return nullptr;
+        }
     } else if (GR_GL_TEXTURE_2D != idDesc.fInfo.fTarget) {
         return nullptr;
     }
 
     // Sample count is interpreted to mean the number of samples that Gr code should allocate
     // for a render buffer that resolves to the texture. We don't support MSAA textures.
     if (desc.fSampleCnt && !renderTarget) {
         return nullptr;
     }
 
@@ skipping 1500 matching lines @@
         const GrSwizzle& swizzle = this->glCaps().glslCaps()->configOutputSwizzle(
             pipeline.getRenderTarget()->config());
         this->flushBlend(blendInfo, swizzle);
     }
 
     SkSTArray<8, const GrTextureAccess*> textureAccesses;
     program->setData(primProc, pipeline, &textureAccesses);
 
     int numTextureAccesses = textureAccesses.count();
     for (int i = 0; i < numTextureAccesses; i++) {
-        this->bindTexture(i, textureAccesses[i]->getParams(),
-                          static_cast<GrGLTexture*>(textureAccesses[i]->getTexture()));
+        GrGLTexture* texture = static_cast<GrGLTexture*>(textureAccesses[i]->getTexture());
+        if (!texture->supportsTextureParams()) {
+            this->bindTexture(i, texture);
+        } else {
+            this->flushTexture(i, textureAccesses[i]->getParams(), texture);
+        }
     }
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(pipeline.getRenderTarget());
     this->flushStencil(pipeline.getStencil());
     this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), glRT->origin());
     this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), !pipeline.getStencil().isDisabled());
 
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, nullptr);
@@ skipping 1147 matching lines @@
         if (!fHWBlendState.fConstColorValid || fHWBlendState.fConstColor != blendConst) {
             GrGLfloat c[4];
             GrColorToRGBAFloat(blendConst, c);
             GL_CALL(BlendColor(c[0], c[1], c[2], c[3]));
             fHWBlendState.fConstColor = blendConst;
             fHWBlendState.fConstColorValid = true;
         }
     }
 }
 
+void GrGLGpu::bindTexture(int unitIdx, GrGLTexture* texture) {
+    SkASSERT(texture);
+
+    // If we created a rt/tex and rendered to it without using a texture and now we're texturing
+    // from the rt it will still be the last bound texture, but it needs resolving. So keep this
+    // out of the "last != next" check.
+    GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
+    if (texRT) {
+        this->onResolveRenderTarget(texRT);
+    }
+
+    if (fHWBoundTextureUniqueIDs[unitIdx] != texture->getUniqueID()) {
+        this->setTextureUnit(unitIdx);
+        GL_CALL(BindTexture(texture->target(), texture->textureID()));
+        fHWBoundTextureUniqueIDs[unitIdx] = texture->getUniqueID();
+    }
+}
+
 static inline GrGLenum tile_to_gl_wrap(SkShader::TileMode tm) {
     static const GrGLenum gWrapModes[] = {
         GR_GL_CLAMP_TO_EDGE,
         GR_GL_REPEAT,
         GR_GL_MIRRORED_REPEAT
     };
     GR_STATIC_ASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gWrapModes));
     GR_STATIC_ASSERT(0 == SkShader::kClamp_TileMode);
     GR_STATIC_ASSERT(1 == SkShader::kRepeat_TileMode);
     GR_STATIC_ASSERT(2 == SkShader::kMirror_TileMode);
@@ skipping 20 matching lines @@
   the generated shader code. This potentially allows greater reuse of cached shaders. */
 static void get_tex_param_swizzle(GrPixelConfig config,
                                   const GrGLCaps& caps,
                                   GrGLenum* glSwizzle) {
     const GrSwizzle& swizzle = caps.configSwizzle(config);
     for (int i = 0; i < 4; ++i) {
         glSwizzle[i] = get_component_enum_from_char(swizzle.c_str()[i]);
     }
 }
 
-void GrGLGpu::bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
-    SkASSERT(texture);
+void GrGLGpu::flushTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
+    this->bindTexture(unitIdx, texture);
 
 #ifdef SK_DEBUG
     if (!this->caps()->npotTextureTileSupport()) {
         const bool tileX = SkShader::kClamp_TileMode != params.getTileModeX();
         const bool tileY = SkShader::kClamp_TileMode != params.getTileModeY();
         if (tileX || tileY) {
             const int w = texture->width();
             const int h = texture->height();
             SkASSERT(SkIsPow2(w) && SkIsPow2(h));
         }
     }
 #endif
 
-    // If we created a rt/tex and rendered to it without using a texture and now we're texturing
-    // from the rt it will still be the last bound texture, but it needs resolving. So keep this
-    // out of the "last != next" check.
-    GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
-    if (texRT) {
-        this->onResolveRenderTarget(texRT);
-    }
-
-    uint32_t textureID = texture->getUniqueID();
-    GrGLenum target = texture->target();
-    if (fHWBoundTextureUniqueIDs[unitIdx] != textureID) {
-        this->setTextureUnit(unitIdx);
-        GL_CALL(BindTexture(target, texture->textureID()));
-        fHWBoundTextureUniqueIDs[unitIdx] = textureID;
-    }
-
     ResetTimestamp timestamp;
     const GrGLTexture::TexParams& oldTexParams = texture->getCachedTexParams(&timestamp);
     bool setAll = timestamp < this->getResetTimestamp();
     GrGLTexture::TexParams newTexParams;
 
     static GrGLenum glMinFilterModes[] = {
         GR_GL_NEAREST,
         GR_GL_LINEAR,
         GR_GL_LINEAR_MIPMAP_LINEAR
     };
     static GrGLenum glMagFilterModes[] = {
         GR_GL_NEAREST,
         GR_GL_LINEAR,
         GR_GL_LINEAR
     };
+
     GrTextureParams::FilterMode filterMode = params.filterMode();
+    GrGLenum target = texture->target();
 
     if (GrTextureParams::kMipMap_FilterMode == filterMode) {
         if (!this->caps()->mipMapSupport() || GrPixelConfigIsCompressed(texture->config())) {
             filterMode = GrTextureParams::kBilerp_FilterMode;
         }
     }
 
     newTexParams.fMinFilter = glMinFilterModes[filterMode];
     newTexParams.fMagFilter = glMagFilterModes[filterMode];
 
@@ skipping 420 matching lines @@
             fsOutName = oFragColor.c_str();
         } else {
             fsOutName = "gl_FragColor";
         }
         fshaderTxt.appendf(
             "// Copy Program FS\n"
             "void main() {"
             "  %s = %s(u_texture, v_texCoord);"
             "}",
             fsOutName,
-            GrGLSLTexture2DFunctionName(kVec2f_GrSLType, kSamplerTypes[i], this->glslGeneration())
+            GrGLSLTextureFunctionName(kVec2f_GrSLType, kSamplerTypes[i], this->glslGeneration())
         );
 
         GL_CALL_RET(fCopyPrograms[i].fProgram, CreateProgram());
         const char* str;
         GrGLint length;
 
         str = vshaderTxt.c_str();
         length = SkToInt(vshaderTxt.size());
         GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[i].fProgram,
                                                       GR_GL_VERTEX_SHADER, &str, &length, 1,
@@ skipping 195 matching lines @@
 
 void GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
                                 GrSurface* src,
                                 const SkIRect& srcRect,
                                 const SkIPoint& dstPoint) {
     int w = srcRect.width();
     int h = srcRect.height();
 
     GrGLTexture* srcTex = static_cast<GrGLTexture*>(src->asTexture());
     GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
-    this->bindTexture(0, params, srcTex);
+    this->flushTexture(0, params, srcTex);
 
     GrGLIRect dstVP;
     this->bindSurfaceFBOForCopy(dst, GR_GL_FRAMEBUFFER, &dstVP, kDst_TempFBOTarget);
     this->flushViewport(dstVP);
     fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
 
     SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY, w, h);
 
     int progIdx = TextureTargetToCopyProgramIdx(srcTex->target());
 
@@ skipping 362 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }