Revise layer, extension and feature setup for Vulkan

src/gpu/vk/GrVkCaps.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 "GrVkCaps.h"
 
 #include "GrVkUtil.h"
 #include "glsl/GrGLSLCaps.h"
 #include "vk/GrVkInterface.h"
+#include "vk/GrVkBackendContext.h"
 
 GrVkCaps::GrVkCaps(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
-                   VkPhysicalDevice physDev) : INHERITED(contextOptions) {
+                   VkPhysicalDevice physDev, uint32_t featureFlags) : INHERITED(contextOptions) {
     /**************************************************************************
     * GrDrawTargetCaps fields
     **************************************************************************/
     fMipMapSupport = false; //TODO: figure this out
     fNPOTTextureTileSupport = false; //TODO: figure this out
     fTwoSidedStencilSupport = false; //TODO: figure this out
     fStencilWrapOpsSupport = false; //TODO: figure this out
     fDiscardRenderTargetSupport = false; //TODO: figure this out
     fReuseScratchTextures = true; //TODO: figure this out
     fGpuTracingSupport = false; //TODO: figure this out
     fCompressedTexSubImageSupport = false; //TODO: figure this out
     fOversizedStencilSupport = false; //TODO: figure this out
 
     fUseDrawInsteadOfClear = false; //TODO: figure this out
 
     fMapBufferFlags = kNone_MapFlags; //TODO: figure this out
     fGeometryBufferMapThreshold = SK_MaxS32;  //TODO: figure this out
 
     fMaxRenderTargetSize = 4096; // minimum required by spec
     fMaxTextureSize = 4096; // minimum required by spec
     fMaxColorSampleCount = 4; // minimum required by spec
     fMaxStencilSampleCount = 4; // minimum required by spec
 
 
     fShaderCaps.reset(new GrGLSLCaps(contextOptions));
 
-    this->init(contextOptions, vkInterface, physDev);
+    this->init(contextOptions, vkInterface, physDev, featureFlags);
 }
 
 void GrVkCaps::init(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
-                    VkPhysicalDevice physDev) {
+                    VkPhysicalDevice physDev, uint32_t featureFlags) {
 
     VkPhysicalDeviceProperties properties;
     GR_VK_CALL(vkInterface, GetPhysicalDeviceProperties(physDev, &properties));
 
-    VkPhysicalDeviceFeatures features;
-    GR_VK_CALL(vkInterface, GetPhysicalDeviceFeatures(physDev, &features));
-
     VkPhysicalDeviceMemoryProperties memoryProperties;
     GR_VK_CALL(vkInterface, GetPhysicalDeviceMemoryProperties(physDev, &memoryProperties));
 
-    this->initGrCaps(properties, features, memoryProperties);
-    this->initGLSLCaps(features, properties);
+    this->initGrCaps(properties, memoryProperties, featureFlags);
+    this->initGLSLCaps(properties, featureFlags);
     this->initConfigTexturableTable(vkInterface, physDev);
     this->initConfigRenderableTable(vkInterface, physDev);
     this->initStencilFormats(vkInterface, physDev);
 
 
 
     this->applyOptionsOverrides(contextOptions);
     // need to friend GrVkCaps in GrGLSLCaps.h
     // GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
     // glslCaps->applyOptionsOverrides(contextOptions);
@@ skipping 24 matching lines @@
 
 void GrVkCaps::initSampleCount(const VkPhysicalDeviceProperties& properties) {
     VkSampleCountFlags colorSamples = properties.limits.framebufferColorSampleCounts;
     VkSampleCountFlags stencilSamples = properties.limits.framebufferStencilSampleCounts;
 
     fMaxColorSampleCount = get_max_sample_count(colorSamples);
     fMaxStencilSampleCount = get_max_sample_count(stencilSamples);
 }
 
 void GrVkCaps::initGrCaps(const VkPhysicalDeviceProperties& properties,
-                          const VkPhysicalDeviceFeatures& features,
-                          const VkPhysicalDeviceMemoryProperties& memoryProperites) {
+                          const VkPhysicalDeviceMemoryProperties& memoryProperties,
+                          uint32_t featureFlags) {
     fMaxVertexAttributes = properties.limits.maxVertexInputAttributes;
     // We could actually query and get a max size for each config, however maxImageDimension2D will
     // give the minimum max size across all configs. So for simplicity we will use that for now.
     fMaxRenderTargetSize = properties.limits.maxImageDimension2D;
     fMaxTextureSize = properties.limits.maxImageDimension2D;
 
     this->initSampleCount(properties);
 
     // Assuming since we will always map in the end to upload the data we might as well just map
     // from the get go. There is no hard data to suggest this is faster or slower.
     fGeometryBufferMapThreshold = 0;
 
     fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag;
 
     fStencilWrapOpsSupport = true;
     fOversizedStencilSupport = true;
 }
 
-void GrVkCaps::initGLSLCaps(const VkPhysicalDeviceFeatures& features,
-                            const VkPhysicalDeviceProperties& properties) {
+void GrVkCaps::initGLSLCaps(const VkPhysicalDeviceProperties& properties,
+                            uint32_t featureFlags) {
     GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
     glslCaps->fVersionDeclString = "#version 310 es\n";
 
     // fConfigOutputSwizzle will default to RGBA so we only need to set it for alpha only config.
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
         GrPixelConfig config = static_cast<GrPixelConfig>(i);
         if (GrPixelConfigIsAlphaOnly(config)) {
             glslCaps->fConfigTextureSwizzle[i] = GrSwizzle::RRRR();
             glslCaps->fConfigOutputSwizzle[i] = GrSwizzle::AAAA();
         } else {
             glslCaps->fConfigTextureSwizzle[i] = GrSwizzle::RGBA();
         }
     }
 
     // Vulkan is based off ES 3.0 so the following should all be supported
     glslCaps->fUsesPrecisionModifiers = true;
     glslCaps->fFlatInterpolationSupport = true;
 
     // GrShaderCaps
 
     glslCaps->fShaderDerivativeSupport = true;
-    glslCaps->fGeometryShaderSupport = features.geometryShader == VK_TRUE;
+    glslCaps->fGeometryShaderSupport = SkToBool(featureFlags & kGeometryShader_GrVkFeatureFlag);
 #if 0
     // For now disabling dual source blending till we get it hooked up in the rest of system
-    glslCaps->fDualSourceBlendingSupport = features.dualSrcBlend;
+    glslCaps->fDualSourceBlendingSupport = SkToBool(featureFlags & kDualSrcBlend_GrVkFeatureFlag);
 #endif
     glslCaps->fIntegerSupport = true;
 
     glslCaps->fMaxVertexSamplers =
     glslCaps->fMaxGeometrySamplers =
     glslCaps->fMaxFragmentSamplers = SkTMin(properties.limits.maxPerStageDescriptorSampledImages,
                                             properties.limits.maxPerStageDescriptorSamplers);
     glslCaps->fMaxCombinedSamplers = SkTMin(properties.limits.maxDescriptorSetSampledImages,
                                             properties.limits.maxDescriptorSetSamplers);
 }
@@ skipping 111 matching lines @@
                   // internal Format             stencil bits      total bits        packed?
         gS8    = { VK_FORMAT_S8_UINT,            8,                 8,               false },
         gD24S8 = { VK_FORMAT_D24_UNORM_S8_UINT,  8,                32,               true };
 
     // I'm simply assuming that these two will be supported since they are used in example code.
     // TODO: Actaully figure this out
     SET_CONFIG_CAN_STENCIL(gS8);
     SET_CONFIG_CAN_STENCIL(gD24S8);
 }