Vulkan: prepare for buffer format fallbacks.

scripts/run_code_generation_hashes.json

@@ -66,9 +66,9 @@
   "Vulkan format:src/libANGLE/renderer/angle_format_map.json":
     "82d80c3be2cdfcc17aec07cf2223907f",
   "Vulkan format:src/libANGLE/renderer/vulkan/gen_vk_format_table.py":
-    "85a1e412d2dc8d3c06a8f3249e0aae48",
+    "86aa4d78d3f1c82f938f1175237c86ce",
   "Vulkan format:src/libANGLE/renderer/vulkan/vk_format_map.json":
-    "0ea1d6c72f5ffabecbf8d5d68a527dc7",
+    "ad20bf1583747eb8e70b991135803c3c",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py":
     "c1cc895645db3fe1cd284352890c219e",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/FullScreenQuad.vert":

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -135,7 +135,7 @@ angle::Result PixelBuffer::stageSubresourceUpdate(ContextVk *contextVk,
 
     const uint8_t *source = pixels + inputSkipBytes;
 
-    LoadImageFunctionInfo loadFunction = vkFormat.loadFunctions(type);
+    LoadImageFunctionInfo loadFunction = vkFormat.textureLoadFunctions(type);
 
     loadFunction.loadFunction(extents.width, extents.height, extents.depth, source, inputRowPitch,
                               inputDepthPitch, stagingPointer, outputRowPitch, outputDepthPitch);
@@ -190,7 +190,7 @@ angle::Result PixelBuffer::stageSubresourceUpdateFromFramebuffer(
 
     const vk::Format &vkFormat         = renderer->getFormat(formatInfo.sizedInternalFormat);
     const angle::Format &storageFormat = vkFormat.textureFormat();
-    LoadImageFunctionInfo loadFunction = vkFormat.loadFunctions(formatInfo.type);
+    LoadImageFunctionInfo loadFunction = vkFormat.textureLoadFunctions(formatInfo.type);
 
     size_t outputRowPitch   = storageFormat.pixelBytes * clippedRectangle.width;
     size_t outputDepthPitch = outputRowPitch * clippedRectangle.height;
@@ -590,7 +590,7 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
     const gl::Offset modifiedDestOffset(destOffset.x + sourceArea.x - sourceArea.x,
                                         destOffset.y + sourceArea.y - sourceArea.y, 0);
 
-    ContextVk *contextVk = vk::GetImpl(context);
+    ContextVk *contextVk         = vk::GetImpl(context);
     RendererVk *renderer         = contextVk->getRenderer();
     FramebufferVk *framebufferVk = vk::GetImpl(source);
 

src/libANGLE/renderer/vulkan/gen_vk_format_table.py

@@ -57,92 +57,85 @@ void Format::initialize(VkPhysicalDevice physicalDevice, const angle::Format &an
 }}  // namespace rx
 """
 
-empty_format_entry_template = """{space}case angle::Format::ID::{format_id}:
-{space}    // This format is not implemented in Vulkan.
-{space}    break;
+empty_format_entry_template = """case angle::Format::ID::{format_id}:
+// This format is not implemented in Vulkan.
+break;
 """
 
-format_entry_template = """{space}case angle::Format::ID::{format_id}:
-{space}{{
-{space}    internalFormat = {internal_format};
-{space}    textureFormatID = angle::Format::ID::{texture};
-{space}    vkTextureFormat = {vk_texture_format};
-{space}    bufferFormatID = angle::Format::ID::{buffer};
-{space}    vkBufferFormat = {vk_buffer_format};
-{space}    dataInitializerFunction = {initializer};
-{space}    break;
-{space}}}
+format_entry_template = """case angle::Format::ID::{format_id}:
+internalFormat = {internal_format};
+{texture_template}
+{buffer_template}
+break;
 """
 
-# This currently only handles texture fallback formats.
-fallback_format_entry_template = """{space}case angle::Format::ID::{format_id}:
-{space}{{
-{space}    internalFormat = {internal_format};
-{space}    if (!HasFullFormatSupport(physicalDevice, {vk_texture_format}))
-{space}    {{
-{space}        textureFormatID = angle::Format::ID::{fallback_texture};
-{space}        vkTextureFormat = {fallback_vk_texture_format};
-{space}        dataInitializerFunction = {fallback_initializer};
-{space}        ASSERT(HasFullFormatSupport(physicalDevice, {fallback_vk_texture_format}));
-{space}    }}
-{space}    else
-{space}    {{
-{space}        textureFormatID = angle::Format::ID::{texture};
-{space}        vkTextureFormat = {vk_texture_format};
-{space}        dataInitializerFunction = {initializer};
-{space}    }}
-{space}    bufferFormatID = angle::Format::ID::{buffer};
-{space}    vkBufferFormat = {vk_buffer_format};
-{space}    break;
-{space}}}
-"""
+texture_basic_template = """textureFormatID = angle::Format::ID::{texture};
+vkTextureFormat = {vk_texture_format};
+textureInitializerFunction = {texture_initializer};"""
 
-def gen_format_case(angle, internal_format, vk_json_data):
+texture_fallback_template = """initTextureFallback(physicalDevice,
+angle::Format::ID::{texture},
+{vk_texture_format},
+{texture_initializer},
+angle::Format::ID::{texture_fallback},
+{vk_texture_format_fallback},
+{texture_initializer_fallback});"""
+
+buffer_basic_template = """bufferFormatID = angle::Format::ID::{buffer};
+vkBufferFormat = {vk_buffer_format};"""
+
+buffer_fallback_template = """initBufferFallback(physicalDevice,
+angle::Format::ID::{buffer},
+{vk_buffer_format},
+angle::Format::ID::{buffer_fallback},
+{vk_buffer_format_fallback});"""
 
+def gen_format_case(angle, internal_format, vk_json_data):
     vk_map = vk_json_data["map"]
     vk_overrides = vk_json_data["overrides"]
     vk_fallbacks = vk_json_data["fallbacks"]
-
-    args = {
-        "space": "        ",
-        "format_id": angle,
-        "internal_format": internal_format
-    }
+    args = { "format_id" : angle }
 
     if ((angle not in vk_map) and (angle not in vk_overrides) and
         (angle not in vk_fallbacks)) or angle == 'NONE':
         return empty_format_entry_template.format(**args)
 
-    template = format_entry_template
-
-    if angle in vk_map:
-        args["buffer"] = angle
-        args["texture"] = angle
-
-    if angle in vk_overrides:
-        args.update(vk_overrides[angle])
-
-    if angle in vk_fallbacks:
-        template = fallback_format_entry_template
-        fallback = vk_fallbacks[angle]
-        assert not "buffer" in fallback, "Buffer fallbacks not yet supported"
-        assert "texture" in fallback, "Fallback must have a texture fallback"
-
-        args["fallback_texture"] = fallback["texture"]
-        args["fallback_vk_texture_format"] = vk_map[fallback["texture"]]
-        args["fallback_initializer"] = angle_format.get_internal_format_initializer(
-            internal_format, fallback["texture"])
-
-    assert "buffer" in args, "Missing buffer format for " + angle
-    assert "texture" in args, "Missing texture format for " + angle
-
-    args["vk_buffer_format"]  = vk_map[args["buffer"]]
-    args["vk_texture_format"] = vk_map[args["texture"]]
-
-    args["initializer"] = angle_format.get_internal_format_initializer(
-        internal_format, args["texture"])
-
-    return template.format(**args)
+    def get_formats_and_template(format, type, basic_template, fallback_template):
+        format = vk_overrides.get(format, {}).get(type, format)
+        fallback = vk_fallbacks.get(format, {}).get(type, "NONE")
+        if format not in vk_map:
+            format = "NONE"
+            template = ""
+        elif fallback == "NONE":
+            template = basic_template
+        else:
+            template = fallback_template
+        return format, fallback, template
+
+    texture_format, texture_fallback, texture_template = get_formats_and_template(
+                angle, "texture", texture_basic_template, texture_fallback_template)
+    buffer_format, buffer_fallback, buffer_template = get_formats_and_template(
+                angle, "buffer", buffer_basic_template, buffer_fallback_template)
+
+    args.update(
+        internal_format=internal_format,
+        texture_template=texture_template,
+        texture=texture_format,
+        vk_texture_format=vk_map[texture_format],
+        texture_initializer=angle_format.get_internal_format_initializer(internal_format,
+                                                                         texture_format),
+        texture_fallback=texture_fallback,
+        vk_texture_format_fallback=vk_map[texture_fallback],
+        texture_initializer_fallback=angle_format.get_internal_format_initializer(internal_format,
+                                                                                  texture_fallback),
+        buffer_template=buffer_template,
+        buffer=buffer_format,
+        vk_buffer_format=vk_map[buffer_format],
+        buffer_fallback=buffer_fallback,
+        vk_buffer_format_fallback=vk_map[buffer_fallback],
+    )
+
+    return format_entry_template.format(**args).format(**args)
 
 input_file_name = 'vk_format_map.json'
 out_file_name = 'vk_format_table'

src/libANGLE/renderer/vulkan/vk_format_map.json

@@ -203,23 +203,18 @@
     },
     "overrides": {
         "A8_UNORM": {
-            "buffer": "NONE",
             "texture": "R8_UNORM"
         },
         "L8_UNORM": {
-            "buffer": "NONE",
             "texture": "R8_UNORM"
         },
         "L8A8_UNORM": {
-            "buffer": "NONE",
             "texture": "R8G8_UNORM"
         },
         "R4G4B4A4_UNORM": {
-            "buffer": "NONE",
             "texture": "R8G8B8A8_UNORM"
         },
         "R5G5B5A1_UNORM": {
-            "buffer": "NONE",
             "texture": "A1R5G5B5_UNORM"
         },
         "R8G8B8_UNORM": {

src/libANGLE/renderer/vulkan/vk_format_utils.cpp

@@ -42,6 +42,20 @@ void FillTextureFormatCaps(const VkFormatProperties &formatProperties,
     outTextureCaps->renderbuffer = outTextureCaps->textureAttachment;
 }
 
+bool HasFullTextureFormatSupport(VkPhysicalDevice physicalDevice, VkFormat vkFormat)
+{
+    VkFormatProperties formatProperties;
+    vk::GetFormatProperties(physicalDevice, vkFormat, &formatProperties);
+
+    constexpr uint32_t kBitsColor =
+        (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
+         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
+    constexpr uint32_t kBitsDepth = (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+
+    return HasFormatFeatureBits(kBitsColor, formatProperties) ||
+           HasFormatFeatureBits(kBitsDepth, formatProperties);
+}
+
 }  // anonymous namespace
 
 namespace vk
@@ -70,20 +84,6 @@ void GetFormatProperties(VkPhysicalDevice physicalDevice,
     }
 }
 
-bool HasFullFormatSupport(VkPhysicalDevice physicalDevice, VkFormat vkFormat)
-{
-    VkFormatProperties formatProperties;
-    GetFormatProperties(physicalDevice, vkFormat, &formatProperties);
-
-    constexpr uint32_t kBitsColor =
-        (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
-         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
-    constexpr uint32_t kBitsDepth = (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
-
-    return HasFormatFeatureBits(kBitsColor, formatProperties) ||
-           HasFormatFeatureBits(kBitsDepth, formatProperties);
-}
-
 // Format implementation.
 Format::Format()
     : angleFormatID(angle::Format::ID::NONE),
@@ -92,9 +92,46 @@ Format::Format()
       vkTextureFormat(VK_FORMAT_UNDEFINED),
       bufferFormatID(angle::Format::ID::NONE),
       vkBufferFormat(VK_FORMAT_UNDEFINED),
-      dataInitializerFunction(nullptr),
-      loadFunctions()
+      textureInitializerFunction(nullptr),
+      textureLoadFunctions()
+{
+}
+
+void Format::initTextureFallback(VkPhysicalDevice physicalDevice,
+                                 angle::Format::ID format,
+                                 VkFormat vkFormat,
+                                 InitializeTextureDataFunction initializer,
+                                 angle::Format::ID fallbackFormat,
+                                 VkFormat fallbackVkFormat,
+                                 InitializeTextureDataFunction fallbackInitializer)
+{
+    ASSERT(format != angle::Format::ID::NONE);
+    ASSERT(fallbackFormat != angle::Format::ID::NONE);
+
+    if (HasFullTextureFormatSupport(physicalDevice, vkFormat))
+    {
+        textureFormatID            = format;
+        vkTextureFormat            = vkFormat;
+        textureInitializerFunction = initializer;
+    }
+    else
+    {
+        textureFormatID            = fallbackFormat;
+        vkTextureFormat            = fallbackVkFormat;
+        textureInitializerFunction = fallbackInitializer;
+        ASSERT(HasFullTextureFormatSupport(physicalDevice, vkTextureFormat));
+    }
+}
+
+void Format::initBufferFallback(VkPhysicalDevice physicalDevice,
+                                angle::Format::ID format,
+                                VkFormat vkFormat,
+                                angle::Format::ID fallbackFormat,
+                                VkFormat fallbackVkFormat)
 {
+    ASSERT(format != angle::Format::ID::NONE);
+    ASSERT(fallbackFormat != angle::Format::ID::NONE);
+    UNIMPLEMENTED();
 }
 
 const angle::Format &Format::textureFormat() const
@@ -141,7 +178,7 @@ void FormatTable::initialize(VkPhysicalDevice physicalDevice,
         const angle::Format &angleFormat = angle::Format::Get(formatID);
         mFormatData[formatIndex].initialize(physicalDevice, angleFormat);
         const GLenum internalFormat = mFormatData[formatIndex].internalFormat;
-        mFormatData[formatIndex].loadFunctions =
+        mFormatData[formatIndex].textureLoadFunctions =
             GetLoadFunctionsMap(internalFormat, mFormatData[formatIndex].textureFormatID);
         mFormatData[formatIndex].angleFormatID = formatID;
 

src/libANGLE/renderer/vulkan/vk_format_utils.h

@@ -41,6 +41,20 @@ struct Format final : private angle::NonCopyable
     // This is an auto-generated method in vk_format_table_autogen.cpp.
     void initialize(VkPhysicalDevice physicalDevice, const angle::Format &angleFormat);
 
+    void initTextureFallback(VkPhysicalDevice physicalDevice,
+                             angle::Format::ID format,
+                             VkFormat vkFormat,
+                             InitializeTextureDataFunction initializer,
+                             angle::Format::ID fallbackFormat,
+                             VkFormat fallbackVkFormat,
+                             InitializeTextureDataFunction fallbackInitializer);
+
+    void initBufferFallback(VkPhysicalDevice physicalDevice,
+                            angle::Format::ID format,
+                            VkFormat vkFormat,
+                            angle::Format::ID fallbackFormat,
+                            VkFormat fallbackVkFormat);
+
     const angle::Format &textureFormat() const;
     const angle::Format &bufferFormat() const;
     const angle::Format &angleFormat() const;
@@ -51,8 +65,8 @@ struct Format final : private angle::NonCopyable
     VkFormat vkTextureFormat;
     angle::Format::ID bufferFormatID;
     VkFormat vkBufferFormat;
-    InitializeTextureDataFunction dataInitializerFunction;
-    LoadFunctionMap loadFunctions;
+    InitializeTextureDataFunction textureInitializerFunction;
+    LoadFunctionMap textureLoadFunctions;
 };
 
 bool operator==(const Format &lhs, const Format &rhs);
@@ -83,8 +97,6 @@ class FormatTable final : angle::NonCopyable
 // initialized to 0.
 const VkFormatProperties &GetMandatoryFormatSupport(VkFormat vkFormat);
 
-bool HasFullFormatSupport(VkPhysicalDevice physicalDevice, VkFormat vkFormat);
-
 }  // namespace vk
 
 }  // namespace rx