Adding 3D lut color filter

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 574 matching lines @@
     // At least some versions of the desktop ES3 drivers for NVIDIA won't accept GL_RED in
     // glTexImage2D for the internal format but will accept GL_R8.
     if (!useSizedFormat && kNVIDIA_GrGLVendor == this->glContext().vendor() &&
         kGLES_GrGLStandard == this->glStandard() && this->glVersion() >= GR_GL_VER(3, 0)) {
         useSizedFormat = true;
     }
     if (!this->configToGLFormats(dataConfig, useSizedFormat, &internalFormat,
                                  &externalFormat, &externalType)) {
         return false;
     }
+    
+    bool is3DTexture = SkToBool(desc.fFlags & k3DTexture_GrTextureFlagBit);
+    if (is3DTexture && !this->glCaps().has3DTexImageSupport()) {
+        return false;
+    }
 
     /*
      *  check whether to allocate a temporary buffer for flipping y or
      *  because our srcData has extra bytes past each row. If so, we need
      *  to trim those off here, since GL ES may not let us specify
      *  GL_UNPACK_ROW_LENGTH.
      */
     bool restoreGLRowLength = false;
     bool swFlipY = false;
     bool glFlipY = false;
@@ skipping 45 matching lines @@
         0 == left && 0 == top &&
         desc.fWidth == width && desc.fHeight == height) {
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         if (useTexStorage) {
             // We never resize  or change formats of textures.
             GL_ALLOC_CALL(this->glInterface(),
                           TexStorage2D(GR_GL_TEXTURE_2D,
                                        1, // levels
                                        internalFormat,
                                        desc.fWidth, desc.fHeight));
+        } else if (is3DTexture) {
+            GL_ALLOC_CALL(this->glInterface(),
+                          TexImage3D(GR_GL_TEXTURE_3D,
+                                     0, // level
+                                     internalFormat,
+                                     desc.fWidth, desc.fHeight,
+                                     desc.fWidth, // FIXME: width is used as depth

[bsalomon, 2014/09/19 13:47:04]

Why not just add a depth to fDesc and get rid of the flag?

[sugoi1, 2014/09/24 19:12:48]

Done.

+                                     0, // border
+                                     externalFormat, externalType,
+                                     data));
         } else {
             GL_ALLOC_CALL(this->glInterface(),
                           TexImage2D(GR_GL_TEXTURE_2D,
                                      0, // level
                                      internalFormat,
                                      desc.fWidth, desc.fHeight,
                                      0, // border
                                      externalFormat, externalType,
                                      data));
         }
         GrGLenum error = check_alloc_error(desc, this->glInterface());
         if (error != GR_GL_NO_ERROR) {
             succeeded = false;
         } else {
             // if we have data and we used TexStorage to create the texture, we
             // now upload with TexSubImage.
             if (data && useTexStorage) {
-                GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
-                                      0, // level
-                                      left, top,
-                                      width, height,
-                                      externalFormat, externalType,
-                                      data));
+                if (is3DTexture) {
+                    GL_CALL(TexSubImage3D(GR_GL_TEXTURE_3D,
+                                          0, // level,
+                                          left, top,
+                                          left, // FIXME: left used as Z offset
+                                          desc.fWidth, desc.fHeight,
+                                          desc.fWidth, // FIXME: width is used as depth
+                                          externalFormat, externalType,
+                                          data));
+                } else {
+                    GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
+                                          0, // level
+                                          left, top,
+                                          width, height,
+                                          externalFormat, externalType,
+                                          data));
+                }
             }
         }
     } else {
         if (swFlipY || glFlipY) {
             top = desc.fHeight - (top + height);
         }
-        GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
-                              0, // level
-                              left, top,
-                              width, height,
-                              externalFormat, externalType, data));
+        if (is3DTexture) {
+            GL_CALL(TexSubImage3D(GR_GL_TEXTURE_3D,
+                                  0, // level,
+                                  left, top,
+                                  left, // FIXME: left used as Z offset
+                                  desc.fWidth, desc.fHeight,
+                                  desc.fWidth, // FIXME: width is used as depth
+                                  externalFormat, externalType,
+                                  data));
+        } else {
+            GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
+                                  0, // level
+                                  left, top,
+                                  width, height,
+                                  externalFormat, externalType, data));
+        }
     }
 
     if (restoreGLRowLength) {
         SkASSERT(this->glCaps().unpackRowLengthSupport());
         GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
     }
     if (glFlipY) {
         GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_FALSE));
     }
     return succeeded;
@@ skipping 30 matching lines @@
         SkASSERT(height <= desc.fHeight);
     }
 #endif
 
     // Make sure that the width and height that we pass to OpenGL
     // is a multiple of the block size.
     int dataSize = GrCompressedFormatDataSize(desc.fConfig, width, height);
 
     // We only need the internal format for compressed 2D textures.
     GrGLenum internalFormat = 0;
-    if (!this->configToGLFormats(desc.fConfig, false, &internalFormat, NULL, NULL)) {
+    if (!this->configToGLFormats(desc.fConfig, false, &internalFormat, NULL, NULL) ||
+        // Compressed 3D textures not supported
+        SkToBool(desc.fFlags & k3DTexture_GrTextureFlagBit)) {
         return false;
     }
 
     if (isNewTexture) {
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(),
                       CompressedTexImage2D(GR_GL_TEXTURE_2D,
                                            0, // level
                                            internalFormat,
                                            width, height,
@@ skipping 1842 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }