Update vulkan format features in caps.

src/gpu/vk/GrVkCaps.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrVkCaps_DEFINED
 #define GrVkCaps_DEFINED
 
@@ skipping 13 matching lines @@
 
     /**
      * Creates a GrVkCaps that is set such that nothing is supported. The init function should
      * be called to fill out the caps.
      */
     GrVkCaps(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
              VkPhysicalDevice device, uint32_t featureFlags, uint32_t extensionFlags);
 
     bool isConfigTexturable(GrPixelConfig config) const override {
         SkASSERT(kGrPixelConfigCnt > config);
-        return fConfigTextureSupport[config];
+        return SkToBool(ConfigInfo::kTextureable_Flag & fConfigTable[config].fOptimalFlags);
     }
 
     bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const override {
         SkASSERT(kGrPixelConfigCnt > config);
-        return fConfigRenderSupport[config][withMSAA];
+        return SkToBool(ConfigInfo::kRenderable_Flag & fConfigTable[config].fOptimalFlags);
+    }
+
+    bool isConfigTexurableLinearly(GrPixelConfig config) const {
+        SkASSERT(kGrPixelConfigCnt > config);
+        return SkToBool(ConfigInfo::kTextureable_Flag & fConfigTable[config].fLinearFlags);
     }
 
     bool isConfigRenderableLinearly(GrPixelConfig config, bool withMSAA) const {
         SkASSERT(kGrPixelConfigCnt > config);
-        return fConfigLinearRenderSupport[config][withMSAA];
+        return !withMSAA && SkToBool(ConfigInfo::kRenderable_Flag &
+                                     fConfigTable[config].fLinearFlags);
     }
 
-    bool isConfigTexurableLinearly(GrPixelConfig config) const {
+    bool configCanBeDstofBlit(GrPixelConfig config, bool linearTiled) const {
         SkASSERT(kGrPixelConfigCnt > config);
-        return fConfigLinearTextureSupport[config];
+        const uint16_t& flags = linearTiled ? fConfigTable[config].fLinearFlags :
+                                              fConfigTable[config].fOptimalFlags;
+        return SkToBool(ConfigInfo::kBlitDst_Flag & flags);
+    }
+
+    bool configCanBeSrcofBlit(GrPixelConfig config, bool linearTiled) const {
+        SkASSERT(kGrPixelConfigCnt > config);
+        const uint16_t& flags = linearTiled ? fConfigTable[config].fLinearFlags :
+                                              fConfigTable[config].fOptimalFlags;
+        return SkToBool(ConfigInfo::kBlitSrc_Flag & flags);
     }
 
     bool canUseGLSLForShaderModule() const {
         return fCanUseGLSLForShaderModule;
     }
 
     /**
-     * Gets an array of legal stencil formats. These formats are not guaranteed to be supported by
-     * the driver but are legal VK_TEXTURE_FORMATs.
+     * Returns both a supported and most prefered stencil format to use in draws.
      */
-    const SkTArray<StencilFormat, true>& stencilFormats() const {
-        return fStencilFormats;
-    }
-
-    /**
-     * Gets an array of legal stencil formats. These formats are not guaranteed to be supported by
-     * the driver but are legal VK_TEXTURE_FORMATs.
-     */
-    const SkTArray<StencilFormat, true>& linearStencilFormats() const {
-        return fLinearStencilFormats;
+    const StencilFormat& preferedStencilFormat() const {
+        return fPreferedStencilFormat;
     }
 
     GrGLSLCaps* glslCaps() const { return reinterpret_cast<GrGLSLCaps*>(fShaderCaps.get()); }
 
 private:
     void init(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
               VkPhysicalDevice device, uint32_t featureFlags, uint32_t extensionFlags);
     void initGrCaps(const VkPhysicalDeviceProperties&,
                     const VkPhysicalDeviceMemoryProperties&,
                     uint32_t featureFlags);
     void initGLSLCaps(const VkPhysicalDeviceProperties&, uint32_t featureFlags);
     void initSampleCount(const VkPhysicalDeviceProperties& properties);
-    void initConfigRenderableTable(const GrVkInterface* iface, VkPhysicalDevice physDev);
-    void initConfigTexturableTable(const GrVkInterface* iface, VkPhysicalDevice physDev);
-    void initStencilFormats(const GrVkInterface* iface, VkPhysicalDevice physDev);
 
 
-    bool fConfigTextureSupport[kGrPixelConfigCnt];
-    // For Vulkan we track whether a config is supported linearly (without need for swizzling)
-    bool fConfigLinearTextureSupport[kGrPixelConfigCnt];
+    void initConfigTable(const GrVkInterface*, VkPhysicalDevice);
+    void initStencilFormat(const GrVkInterface* iface, VkPhysicalDevice physDev);
 
-    // The first entry for each config is without msaa and the second is with.
-    bool fConfigRenderSupport[kGrPixelConfigCnt][2];
-    // The first entry for each config is without msaa and the second is with.
-    bool fConfigLinearRenderSupport[kGrPixelConfigCnt][2];
+    struct ConfigInfo {
+        ConfigInfo() : fOptimalFlags(0), fLinearFlags(0) {}
 
-    SkTArray<StencilFormat, true> fLinearStencilFormats;
-    SkTArray<StencilFormat, true> fStencilFormats;
+        void init(const GrVkInterface*, VkPhysicalDevice, VkFormat);
+        static void InitConfigFlags(VkFormatFeatureFlags, uint16_t* flags);
+
+        enum {
+            kTextureable_Flag = 0x1,
+            kRenderable_Flag  = 0x2,
+            kBlitSrc_Flag     = 0x4,
+            kBlitDst_Flag     = 0x8,
+        };
+
+        uint16_t fOptimalFlags;
+        uint16_t fLinearFlags;
+    };
+    ConfigInfo fConfigTable[kGrPixelConfigCnt];
+    
+    StencilFormat fPreferedStencilFormat;
 
     // Tells of if we can pass in straight GLSL string into vkCreateShaderModule
     bool fCanUseGLSLForShaderModule;
 
     typedef GrCaps INHERITED;
 };
 
 #endif