Import new functionality for GL4 backend

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 
@@ skipping 21 matching lines @@
     fUnpackFlipYSupport = false;
     fPackRowLengthSupport = false;
     fPackFlipYSupport = false;
     fTextureUsageSupport = false;
     fTexStorageSupport = false;
     fTextureRedSupport = false;
     fImagingSupport = false;
     fTwoFormatLimit = false;
     fFragCoordsConventionSupport = false;
     fVertexArrayObjectSupport = false;
+    fInstancedDrawingSupport = false;
+    fDirectStateAccessSupport = false;
+    fDebugSupport = false;
     fES2CompatibilitySupport = false;
     fMultisampleDisableSupport = false;
     fUseNonVBOVertexAndIndexDynamicData = false;
     fIsCoreProfile = false;
     fFullClearIsFree = false;
 
     fReadPixelsSupportedCache.reset();
 
     fShaderCaps.reset(SkNEW_ARGS(GrGLSLCaps, (contextOptions,
         ctxInfo, glInterface, *this)));
@@ skipping 30 matching lines @@
         }
         else if (ctxInfo.hasExtension("GL_ARM_shader_framebuffer_fetch")) {
             // The arm extension also requires an additional flag which we will set onResetContext
             glslCaps->fFBFetchNeedsCustomOutput = false;
             glslCaps->fFBFetchSupport = true;
             glslCaps->fFBFetchColorName = "gl_LastFragColorARM";
             glslCaps->fFBFetchExtensionString = "GL_ARM_shader_framebuffer_fetch";
         }
     }
 
+    glslCaps->fBindlessTextureSupport = ctxInfo.hasExtension("GL_NV_bindless_texture");
+
     // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader
     glslCaps->fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor();
 
     /**************************************************************************
      * Caps specific to GrGLCaps
      **************************************************************************/
 
     if (kGLES_GrGLStandard == standard) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
                           &fMaxFragmentUniformVectors);
@@ skipping 121 matching lines @@
 
     if (kGL_GrGLStandard == standard) {
         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
                                     ctxInfo.hasExtension("GL_ARB_vertex_array_object") ||
                                     ctxInfo.hasExtension("GL_APPLE_vertex_array_object");
     } else {
         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
                                     ctxInfo.hasExtension("GL_OES_vertex_array_object");
     }
 
+    if ((kGL_GrGLStandard == standard && version >= GR_GL_VER(3,2)) ||
+        (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0))) {
+        fInstancedDrawingSupport = true;
+    } else {
+        fInstancedDrawingSupport = (ctxInfo.hasExtension("GL_ARB_draw_instanced") ||
+                                    ctxInfo.hasExtension("GL_EXT_draw_instanced")) &&
+                                   (ctxInfo.hasExtension("GL_ARB_instanced_arrays") ||
+                                    ctxInfo.hasExtension("GL_EXT_instanced_arrays"));
+    }
+
+    if (kGL_GrGLStandard == standard) {
+        fDirectStateAccessSupport = ctxInfo.hasExtension("GL_EXT_direct_state_access");
+    } else {
+        fDirectStateAccessSupport = false;
+    }
+
+    if (kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) {
+        fDebugSupport = true;
+    } else {
+        fDebugSupport = ctxInfo.hasExtension("GL_KHR_debug");
+    }
+
     if (kGL_GrGLStandard == standard) {
         fES2CompatibilitySupport = ctxInfo.hasExtension("GL_ARB_ES2_compatibility");
     }
     else {
         fES2CompatibilitySupport = true;
     }
 
     if (kGL_GrGLStandard == standard) {
         fMultisampleDisableSupport = true;
     } else {
         fMultisampleDisableSupport = false;
     }
 
     /**************************************************************************
     * GrShaderCaps fields
     **************************************************************************/
 
     glslCaps->fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering");
 
     if (glslCaps->fPathRenderingSupport) {
         if (kGL_GrGLStandard == standard) {
             // We only support v1.3+ of GL_NV_path_rendering which allows us to
             // set individual fragment inputs with ProgramPathFragmentInputGen. The API
             // additions are detected by checking the existence of the function.
-            glslCaps->fPathRenderingSupport =
-                ctxInfo.hasExtension("GL_EXT_direct_state_access") &&
-                ((ctxInfo.version() >= GR_GL_VER(4, 3) ||
+            glslCaps->fPathRenderingSupport = ((ctxInfo.version() >= GR_GL_VER(4, 3) ||
                 ctxInfo.hasExtension("GL_ARB_program_interface_query")) &&
                 gli->fFunctions.fProgramPathFragmentInputGen);
         }
         else {
             glslCaps->fPathRenderingSupport = ctxInfo.version() >= GR_GL_VER(3, 1);
         }
     }
 
     // For now these two are equivalent but we could have dst read in shader via some other method
     glslCaps->fDstReadInShaderSupport = glslCaps->fFBFetchSupport;
@@ skipping 746 matching lines @@
     r.appendf("Pack Flip Y support: %s\n", (fPackFlipYSupport ? "YES": "NO"));
 
     r.appendf("Texture Usage support: %s\n", (fTextureUsageSupport ? "YES": "NO"));
     r.appendf("Texture Storage support: %s\n", (fTexStorageSupport ? "YES": "NO"));
     r.appendf("GL_R support: %s\n", (fTextureRedSupport ? "YES": "NO"));
     r.appendf("GL_ARB_imaging support: %s\n", (fImagingSupport ? "YES": "NO"));
     r.appendf("Two Format Limit: %s\n", (fTwoFormatLimit ? "YES": "NO"));
     r.appendf("Fragment coord conventions support: %s\n",
              (fFragCoordsConventionSupport ? "YES": "NO"));
     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
+    r.appendf("Instanced drawing support: %s\n", (fInstancedDrawingSupport ? "YES": "NO"));
+    r.appendf("Direct state access support: %s\n", (fDirectStateAccessSupport ? "YES": "NO"));
+    r.appendf("Debug support: %s\n", (fDebugSupport ? "YES": "NO"));
     r.appendf("Multisample disable support: %s\n", (fMultisampleDisableSupport ? "YES" : "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("Full screen clear is free: %s\n", (fFullClearIsFree ? "YES" : "NO"));
     return r;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLSLCaps::GrGLSLCaps(const GrContextOptions& options,
                        const GrGLContextInfo& ctxInfo,
                        const GrGLInterface* gli,
                        const GrGLCaps& glCaps) {
     fDropsTileOnZeroDivide = false;
     fFBFetchSupport = false;
     fFBFetchNeedsCustomOutput = false;
+    fBindlessTextureSupport = false;
     fAdvBlendEqInteraction = kNotSupported_AdvBlendEqInteraction;
     fFBFetchColorName = NULL;
     fFBFetchExtensionString = NULL;
 }
 
 SkString GrGLSLCaps::dump() const {
     SkString r = INHERITED::dump();
 
     static const char* kAdvBlendEqInteractionStr[] = {
         "Not Supported",
         "Automatic",
         "General Enable",
         "Specific Enables",
     };
     GR_STATIC_ASSERT(0 == kNotSupported_AdvBlendEqInteraction);
     GR_STATIC_ASSERT(1 == kAutomatic_AdvBlendEqInteraction);
     GR_STATIC_ASSERT(2 == kGeneralEnable_AdvBlendEqInteraction);
     GR_STATIC_ASSERT(3 == kSpecificEnables_AdvBlendEqInteraction);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kAdvBlendEqInteractionStr) == kLast_AdvBlendEqInteraction + 1);
 
     r.appendf("--- GLSL-Specific ---\n");
 
     r.appendf("FB Fetch Support: %s\n", (fFBFetchSupport ? "YES" : "NO"));
     r.appendf("Drops tile on zero divide: %s\n", (fDropsTileOnZeroDivide ? "YES" : "NO"));
+    r.appendf("Bindless texture support: %s\n", (fBindlessTextureSupport ? "YES" : "NO"));
     r.appendf("Advanced blend equation interaction: %s\n",
               kAdvBlendEqInteractionStr[fAdvBlendEqInteraction]);
     return r;
 }
 
 static GrGLenum precision_to_gl_float_type(GrSLPrecision p) {
     switch (p) {
     case kLow_GrSLPrecision:
         return GR_GL_LOW_FLOAT;
     case kMedium_GrSLPrecision:
@@ skipping 69 matching lines @@
     if (fGeometryShaderSupport) {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             fFloatPrecisions[kGeometry_GrShaderType][p] = fFloatPrecisions[kVertex_GrShaderType][p];
         }
     }
 }