[vulkan] Remove vulkan/format_data (#415)

This Cl removes the free methods in vulkan/format_data and attaches them
to the classes where they make the most sense.

19 files changed, 601 insertions, 663 deletions

diff --git a/Android.mk b/Android.mk
index 7d8ca0f..1e5fbad 100644
--- a/Android.mk
+++ b/Android.mk
@@ -54,7 +54,6 @@ LOCAL_SRC_FILES:= \
     src/vulkan/compute_pipeline.cc \
     src/vulkan/device.cc \
     src/vulkan/engine_vulkan.cc \
-    src/vulkan/format_data.cc \
     src/vulkan/frame_buffer.cc \
     src/vulkan/graphics_pipeline.cc \
     src/vulkan/index_buffer.cc \
diff --git a/src/format.cc b/src/format.cc
index 0881379..1429ddf 100644
--- a/src/format.cc
+++ b/src/format.cc
@@ -22,4 +22,152 @@ Format::Format(const Format&) = default;
 
 Format::~Format() = default;
 
+uint32_t Format::GetByteSize() const {
+  switch (type_) {
+    case FormatType::kR4G4_UNORM_PACK8:
+    case FormatType::kR8_SINT:
+    case FormatType::kR8_SNORM:
+    case FormatType::kR8_SRGB:
+    case FormatType::kR8_SSCALED:
+    case FormatType::kR8_UINT:
+    case FormatType::kR8_UNORM:
+    case FormatType::kR8_USCALED:
+    case FormatType::kS8_UINT:
+      return 1U;
+    case FormatType::kB4G4R4A4_UNORM_PACK16:
+    case FormatType::kB5G5R5A1_UNORM_PACK16:
+    case FormatType::kB5G6R5_UNORM_PACK16:
+    case FormatType::kA1R5G5B5_UNORM_PACK16:
+    case FormatType::kD16_UNORM:
+    case FormatType::kR16_SFLOAT:
+    case FormatType::kR16_SINT:
+    case FormatType::kR16_SNORM:
+    case FormatType::kR16_SSCALED:
+    case FormatType::kR16_UINT:
+    case FormatType::kR16_UNORM:
+    case FormatType::kR16_USCALED:
+    case FormatType::kR4G4B4A4_UNORM_PACK16:
+    case FormatType::kR5G5B5A1_UNORM_PACK16:
+    case FormatType::kR5G6B5_UNORM_PACK16:
+    case FormatType::kR8G8_SINT:
+    case FormatType::kR8G8_SNORM:
+    case FormatType::kR8G8_SRGB:
+    case FormatType::kR8G8_SSCALED:
+    case FormatType::kR8G8_UINT:
+    case FormatType::kR8G8_UNORM:
+    case FormatType::kR8G8_USCALED:
+      return 2U;
+    case FormatType::kB8G8R8_SINT:
+    case FormatType::kB8G8R8_SNORM:
+    case FormatType::kB8G8R8_SRGB:
+    case FormatType::kB8G8R8_SSCALED:
+    case FormatType::kB8G8R8_UINT:
+    case FormatType::kB8G8R8_UNORM:
+    case FormatType::kB8G8R8_USCALED:
+    case FormatType::kD16_UNORM_S8_UINT:
+    case FormatType::kR8G8B8_SINT:
+    case FormatType::kR8G8B8_SNORM:
+    case FormatType::kR8G8B8_SRGB:
+    case FormatType::kR8G8B8_SSCALED:
+    case FormatType::kR8G8B8_UINT:
+    case FormatType::kR8G8B8_UNORM:
+    case FormatType::kR8G8B8_USCALED:
+      return 3U;
+    case FormatType::kA2B10G10R10_SINT_PACK32:
+    case FormatType::kA2B10G10R10_SNORM_PACK32:
+    case FormatType::kA2B10G10R10_SSCALED_PACK32:
+    case FormatType::kA2B10G10R10_UINT_PACK32:
+    case FormatType::kA2B10G10R10_UNORM_PACK32:
+    case FormatType::kA2B10G10R10_USCALED_PACK32:
+    case FormatType::kA2R10G10B10_SINT_PACK32:
+    case FormatType::kA2R10G10B10_SNORM_PACK32:
+    case FormatType::kA2R10G10B10_SSCALED_PACK32:
+    case FormatType::kA2R10G10B10_UINT_PACK32:
+    case FormatType::kA2R10G10B10_UNORM_PACK32:
+    case FormatType::kA2R10G10B10_USCALED_PACK32:
+    case FormatType::kA8B8G8R8_SINT_PACK32:
+    case FormatType::kA8B8G8R8_SNORM_PACK32:
+    case FormatType::kA8B8G8R8_SRGB_PACK32:
+    case FormatType::kA8B8G8R8_SSCALED_PACK32:
+    case FormatType::kA8B8G8R8_UINT_PACK32:
+    case FormatType::kA8B8G8R8_UNORM_PACK32:
+    case FormatType::kA8B8G8R8_USCALED_PACK32:
+    case FormatType::kB10G11R11_UFLOAT_PACK32:
+    case FormatType::kB8G8R8A8_SINT:
+    case FormatType::kB8G8R8A8_SNORM:
+    case FormatType::kB8G8R8A8_SRGB:
+    case FormatType::kB8G8R8A8_SSCALED:
+    case FormatType::kB8G8R8A8_UINT:
+    case FormatType::kB8G8R8A8_UNORM:
+    case FormatType::kB8G8R8A8_USCALED:
+    case FormatType::kD24_UNORM_S8_UINT:
+    case FormatType::kD32_SFLOAT:
+    case FormatType::kR16G16_SFLOAT:
+    case FormatType::kR16G16_SINT:
+    case FormatType::kR16G16_SNORM:
+    case FormatType::kR16G16_SSCALED:
+    case FormatType::kR16G16_UINT:
+    case FormatType::kR16G16_UNORM:
+    case FormatType::kR16G16_USCALED:
+    case FormatType::kR32_SFLOAT:
+    case FormatType::kR32_SINT:
+    case FormatType::kR32_UINT:
+    case FormatType::kX8_D24_UNORM_PACK32:
+    case FormatType::kR8G8B8A8_SINT:
+    case FormatType::kR8G8B8A8_SNORM:
+    case FormatType::kR8G8B8A8_SRGB:
+    case FormatType::kR8G8B8A8_SSCALED:
+    case FormatType::kR8G8B8A8_UINT:
+    case FormatType::kR8G8B8A8_UNORM:
+    case FormatType::kR8G8B8A8_USCALED:
+      return 4U;
+    case FormatType::kD32_SFLOAT_S8_UINT:
+      return 5U;
+    case FormatType::kR16G16B16_SFLOAT:
+    case FormatType::kR16G16B16_SINT:
+    case FormatType::kR16G16B16_SNORM:
+    case FormatType::kR16G16B16_SSCALED:
+    case FormatType::kR16G16B16_UINT:
+    case FormatType::kR16G16B16_UNORM:
+    case FormatType::kR16G16B16_USCALED:
+      return 6U;
+    case FormatType::kR16G16B16A16_SFLOAT:
+    case FormatType::kR16G16B16A16_SINT:
+    case FormatType::kR16G16B16A16_SNORM:
+    case FormatType::kR16G16B16A16_SSCALED:
+    case FormatType::kR16G16B16A16_UINT:
+    case FormatType::kR16G16B16A16_UNORM:
+    case FormatType::kR16G16B16A16_USCALED:
+    case FormatType::kR32G32_SFLOAT:
+    case FormatType::kR32G32_SINT:
+    case FormatType::kR32G32_UINT:
+    case FormatType::kR64_SFLOAT:
+    case FormatType::kR64_SINT:
+    case FormatType::kR64_UINT:
+      return 8U;
+    case FormatType::kR32G32B32_SFLOAT:
+    case FormatType::kR32G32B32_SINT:
+    case FormatType::kR32G32B32_UINT:
+      return 12U;
+    case FormatType::kR32G32B32A32_SFLOAT:
+    case FormatType::kR32G32B32A32_SINT:
+    case FormatType::kR32G32B32A32_UINT:
+    case FormatType::kR64G64_SFLOAT:
+    case FormatType::kR64G64_SINT:
+    case FormatType::kR64G64_UINT:
+      return 16U;
+    case FormatType::kR64G64B64_SFLOAT:
+    case FormatType::kR64G64B64_SINT:
+    case FormatType::kR64G64B64_UINT:
+      return 24U;
+    case FormatType::kR64G64B64A64_SFLOAT:
+    case FormatType::kR64G64B64A64_SINT:
+    case FormatType::kR64G64B64A64_UINT:
+      return 32U;
+    default:
+      break;
+  }
+  return 0;
+}
+
 }  // namespace amber
diff --git a/src/format.h b/src/format.h
index f617f09..307340d 100644
--- a/src/format.h
+++ b/src/format.h
@@ -56,19 +56,17 @@ class Format {
   }
   const std::vector<Component>& GetComponents() const { return components_; }
 
-  uint32_t GetByteSize() const {
-    if (pack_size_in_bytes_)
-      return pack_size_in_bytes_;
-
-    uint32_t bits = 0;
-    for (uint32_t j = 0; j < components_.size(); ++j) {
-      bits += components_[j].num_bits;
-    }
-    return bits / 8;
+  uint32_t GetByteSize() const;
+  bool IsFormatKnown() const { return type_ != FormatType::kUnknown; }
+  bool HasStencilComponent() const {
+    return type_ == FormatType::kD24_UNORM_S8_UINT ||
+           type_ == FormatType::kD16_UNORM_S8_UINT ||
+           type_ == FormatType::kD32_SFLOAT_S8_UINT ||
+           type_ == FormatType::kS8_UINT;
   }
 
  private:
-  FormatType type_;
+  FormatType type_ = FormatType::kUnknown;
   uint8_t pack_size_in_bytes_ = 0;
   std::vector<Component> components_;
 };
diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt
index 376ea53..6c6d299 100644
--- a/src/vulkan/CMakeLists.txt
+++ b/src/vulkan/CMakeLists.txt
@@ -19,7 +19,6 @@ set(VULKAN_ENGINE_SOURCES
     compute_pipeline.cc
     device.cc
     engine_vulkan.cc
-    format_data.cc
     frame_buffer.cc
     graphics_pipeline.cc
     index_buffer.cc
diff --git a/src/vulkan/device.cc b/src/vulkan/device.cc
index 6a51330..5621ae1 100644
--- a/src/vulkan/device.cc
+++ b/src/vulkan/device.cc
@@ -24,7 +24,6 @@
 #include <vector>
 
 #include "src/make_unique.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
@@ -463,7 +462,7 @@ Result Device::Initialize(
 
 bool Device::IsFormatSupportedByPhysicalDevice(const Format& format,
                                                BufferType type) {
-  VkFormat vk_format = ToVkFormat(format.GetFormatType());
+  VkFormat vk_format = GetVkFormat(format);
   VkFormatProperties properties = VkFormatProperties();
   GetPtrs()->vkGetPhysicalDeviceFormatProperties(physical_device_, vk_format,
                                                  &properties);
@@ -522,5 +521,402 @@ bool Device::IsDescriptorSetInBounds(uint32_t descriptor_set) const {
   return properties.limits.maxBoundDescriptorSets > descriptor_set;
 }
 
+VkFormat Device::GetVkFormat(const Format& format) const {
+  VkFormat ret = VK_FORMAT_UNDEFINED;
+  switch (format.GetFormatType()) {
+    case FormatType::kUnknown:
+      ret = VK_FORMAT_UNDEFINED;
+      break;
+    case FormatType::kA1R5G5B5_UNORM_PACK16:
+      ret = VK_FORMAT_A1R5G5B5_UNORM_PACK16;
+      break;
+    case FormatType::kA2B10G10R10_SINT_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_SINT_PACK32;
+      break;
+    case FormatType::kA2B10G10R10_SNORM_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_SNORM_PACK32;
+      break;
+    case FormatType::kA2B10G10R10_SSCALED_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
+      break;
+    case FormatType::kA2B10G10R10_UINT_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_UINT_PACK32;
+      break;
+    case FormatType::kA2B10G10R10_UNORM_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+      break;
+    case FormatType::kA2B10G10R10_USCALED_PACK32:
+      ret = VK_FORMAT_A2B10G10R10_USCALED_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_SINT_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_SINT_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_SNORM_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_SNORM_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_SSCALED_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_SSCALED_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_UINT_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_UINT_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_UNORM_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_UNORM_PACK32;
+      break;
+    case FormatType::kA2R10G10B10_USCALED_PACK32:
+      ret = VK_FORMAT_A2R10G10B10_USCALED_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_SINT_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_SINT_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_SNORM_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_SNORM_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_SRGB_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_SRGB_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_SSCALED_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_SSCALED_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_UINT_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_UINT_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_UNORM_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+      break;
+    case FormatType::kA8B8G8R8_USCALED_PACK32:
+      ret = VK_FORMAT_A8B8G8R8_USCALED_PACK32;
+      break;
+    case FormatType::kB10G11R11_UFLOAT_PACK32:
+      ret = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+      break;
+    case FormatType::kB4G4R4A4_UNORM_PACK16:
+      ret = VK_FORMAT_B4G4R4A4_UNORM_PACK16;
+      break;
+    case FormatType::kB5G5R5A1_UNORM_PACK16:
+      ret = VK_FORMAT_B5G5R5A1_UNORM_PACK16;
+      break;
+    case FormatType::kB5G6R5_UNORM_PACK16:
+      ret = VK_FORMAT_B5G6R5_UNORM_PACK16;
+      break;
+    case FormatType::kB8G8R8A8_SINT:
+      ret = VK_FORMAT_B8G8R8A8_SINT;
+      break;
+    case FormatType::kB8G8R8A8_SNORM:
+      ret = VK_FORMAT_B8G8R8A8_SNORM;
+      break;
+    case FormatType::kB8G8R8A8_SRGB:
+      ret = VK_FORMAT_B8G8R8A8_SRGB;
+      break;
+    case FormatType::kB8G8R8A8_SSCALED:
+      ret = VK_FORMAT_B8G8R8A8_SSCALED;
+      break;
+    case FormatType::kB8G8R8A8_UINT:
+      ret = VK_FORMAT_B8G8R8A8_UINT;
+      break;
+    case FormatType::kB8G8R8A8_UNORM:
+      ret = VK_FORMAT_B8G8R8A8_UNORM;
+      break;
+    case FormatType::kB8G8R8A8_USCALED:
+      ret = VK_FORMAT_B8G8R8A8_USCALED;
+      break;
+    case FormatType::kB8G8R8_SINT:
+      ret = VK_FORMAT_B8G8R8_SINT;
+      break;
+    case FormatType::kB8G8R8_SNORM:
+      ret = VK_FORMAT_B8G8R8_SNORM;
+      break;
+    case FormatType::kB8G8R8_SRGB:
+      ret = VK_FORMAT_B8G8R8_SRGB;
+      break;
+    case FormatType::kB8G8R8_SSCALED:
+      ret = VK_FORMAT_B8G8R8_SSCALED;
+      break;
+    case FormatType::kB8G8R8_UINT:
+      ret = VK_FORMAT_B8G8R8_UINT;
+      break;
+    case FormatType::kB8G8R8_UNORM:
+      ret = VK_FORMAT_B8G8R8_UNORM;
+      break;
+    case FormatType::kB8G8R8_USCALED:
+      ret = VK_FORMAT_B8G8R8_USCALED;
+      break;
+    case FormatType::kD16_UNORM:
+      ret = VK_FORMAT_D16_UNORM;
+      break;
+    case FormatType::kD16_UNORM_S8_UINT:
+      ret = VK_FORMAT_D16_UNORM_S8_UINT;
+      break;
+    case FormatType::kD24_UNORM_S8_UINT:
+      ret = VK_FORMAT_D24_UNORM_S8_UINT;
+      break;
+    case FormatType::kD32_SFLOAT:
+      ret = VK_FORMAT_D32_SFLOAT;
+      break;
+    case FormatType::kD32_SFLOAT_S8_UINT:
+      ret = VK_FORMAT_D32_SFLOAT_S8_UINT;
+      break;
+    case FormatType::kR16G16B16A16_SFLOAT:
+      ret = VK_FORMAT_R16G16B16A16_SFLOAT;
+      break;
+    case FormatType::kR16G16B16A16_SINT:
+      ret = VK_FORMAT_R16G16B16A16_SINT;
+      break;
+    case FormatType::kR16G16B16A16_SNORM:
+      ret = VK_FORMAT_R16G16B16A16_SNORM;
+      break;
+    case FormatType::kR16G16B16A16_SSCALED:
+      ret = VK_FORMAT_R16G16B16A16_SSCALED;
+      break;
+    case FormatType::kR16G16B16A16_UINT:
+      ret = VK_FORMAT_R16G16B16A16_UINT;
+      break;
+    case FormatType::kR16G16B16A16_UNORM:
+      ret = VK_FORMAT_R16G16B16A16_UNORM;
+      break;
+    case FormatType::kR16G16B16A16_USCALED:
+      ret = VK_FORMAT_R16G16B16A16_USCALED;
+      break;
+    case FormatType::kR16G16B16_SFLOAT:
+      ret = VK_FORMAT_R16G16B16_SFLOAT;
+      break;
+    case FormatType::kR16G16B16_SINT:
+      ret = VK_FORMAT_R16G16B16_SINT;
+      break;
+    case FormatType::kR16G16B16_SNORM:
+      ret = VK_FORMAT_R16G16B16_SNORM;
+      break;
+    case FormatType::kR16G16B16_SSCALED:
+      ret = VK_FORMAT_R16G16B16_SSCALED;
+      break;
+    case FormatType::kR16G16B16_UINT:
+      ret = VK_FORMAT_R16G16B16_UINT;
+      break;
+    case FormatType::kR16G16B16_UNORM:
+      ret = VK_FORMAT_R16G16B16_UNORM;
+      break;
+    case FormatType::kR16G16B16_USCALED:
+      ret = VK_FORMAT_R16G16B16_USCALED;
+      break;
+    case FormatType::kR16G16_SFLOAT:
+      ret = VK_FORMAT_R16G16_SFLOAT;
+      break;
+    case FormatType::kR16G16_SINT:
+      ret = VK_FORMAT_R16G16_SINT;
+      break;
+    case FormatType::kR16G16_SNORM:
+      ret = VK_FORMAT_R16G16_SNORM;
+      break;
+    case FormatType::kR16G16_SSCALED:
+      ret = VK_FORMAT_R16G16_SSCALED;
+      break;
+    case FormatType::kR16G16_UINT:
+      ret = VK_FORMAT_R16G16_UINT;
+      break;
+    case FormatType::kR16G16_UNORM:
+      ret = VK_FORMAT_R16G16_UNORM;
+      break;
+    case FormatType::kR16G16_USCALED:
+      ret = VK_FORMAT_R16G16_USCALED;
+      break;
+    case FormatType::kR16_SFLOAT:
+      ret = VK_FORMAT_R16_SFLOAT;
+      break;
+    case FormatType::kR16_SINT:
+      ret = VK_FORMAT_R16_SINT;
+      break;
+    case FormatType::kR16_SNORM:
+      ret = VK_FORMAT_R16_SNORM;
+      break;
+    case FormatType::kR16_SSCALED:
+      ret = VK_FORMAT_R16_SSCALED;
+      break;
+    case FormatType::kR16_UINT:
+      ret = VK_FORMAT_R16_UINT;
+      break;
+    case FormatType::kR16_UNORM:
+      ret = VK_FORMAT_R16_UNORM;
+      break;
+    case FormatType::kR16_USCALED:
+      ret = VK_FORMAT_R16_USCALED;
+      break;
+    case FormatType::kR32G32B32A32_SFLOAT:
+      ret = VK_FORMAT_R32G32B32A32_SFLOAT;
+      break;
+    case FormatType::kR32G32B32A32_SINT:
+      ret = VK_FORMAT_R32G32B32A32_SINT;
+      break;
+    case FormatType::kR32G32B32A32_UINT:
+      ret = VK_FORMAT_R32G32B32A32_UINT;
+      break;
+    case FormatType::kR32G32B32_SFLOAT:
+      ret = VK_FORMAT_R32G32B32_SFLOAT;
+      break;
+    case FormatType::kR32G32B32_SINT:
+      ret = VK_FORMAT_R32G32B32_SINT;
+      break;
+    case FormatType::kR32G32B32_UINT:
+      ret = VK_FORMAT_R32G32B32_UINT;
+      break;
+    case FormatType::kR32G32_SFLOAT:
+      ret = VK_FORMAT_R32G32_SFLOAT;
+      break;
+    case FormatType::kR32G32_SINT:
+      ret = VK_FORMAT_R32G32_SINT;
+      break;
+    case FormatType::kR32G32_UINT:
+      ret = VK_FORMAT_R32G32_UINT;
+      break;
+    case FormatType::kR32_SFLOAT:
+      ret = VK_FORMAT_R32_SFLOAT;
+      break;
+    case FormatType::kR32_SINT:
+      ret = VK_FORMAT_R32_SINT;
+      break;
+    case FormatType::kR32_UINT:
+      ret = VK_FORMAT_R32_UINT;
+      break;
+    case FormatType::kR4G4B4A4_UNORM_PACK16:
+      ret = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
+      break;
+    case FormatType::kR4G4_UNORM_PACK8:
+      ret = VK_FORMAT_R4G4_UNORM_PACK8;
+      break;
+    case FormatType::kR5G5B5A1_UNORM_PACK16:
+      ret = VK_FORMAT_R5G5B5A1_UNORM_PACK16;
+      break;
+    case FormatType::kR5G6B5_UNORM_PACK16:
+      ret = VK_FORMAT_R5G6B5_UNORM_PACK16;
+      break;
+    case FormatType::kR64G64B64A64_SFLOAT:
+      ret = VK_FORMAT_R64G64B64A64_SFLOAT;
+      break;
+    case FormatType::kR64G64B64A64_SINT:
+      ret = VK_FORMAT_R64G64B64A64_SINT;
+      break;
+    case FormatType::kR64G64B64A64_UINT:
+      ret = VK_FORMAT_R64G64B64A64_UINT;
+      break;
+    case FormatType::kR64G64B64_SFLOAT:
+      ret = VK_FORMAT_R64G64B64_SFLOAT;
+      break;
+    case FormatType::kR64G64B64_SINT:
+      ret = VK_FORMAT_R64G64B64_SINT;
+      break;
+    case FormatType::kR64G64B64_UINT:
+      ret = VK_FORMAT_R64G64B64_UINT;
+      break;
+    case FormatType::kR64G64_SFLOAT:
+      ret = VK_FORMAT_R64G64_SFLOAT;
+      break;
+    case FormatType::kR64G64_SINT:
+      ret = VK_FORMAT_R64G64_SINT;
+      break;
+    case FormatType::kR64G64_UINT:
+      ret = VK_FORMAT_R64G64_UINT;
+      break;
+    case FormatType::kR64_SFLOAT:
+      ret = VK_FORMAT_R64_SFLOAT;
+      break;
+    case FormatType::kR64_SINT:
+      ret = VK_FORMAT_R64_SINT;
+      break;
+    case FormatType::kR64_UINT:
+      ret = VK_FORMAT_R64_UINT;
+      break;
+    case FormatType::kR8G8B8A8_SINT:
+      ret = VK_FORMAT_R8G8B8A8_SINT;
+      break;
+    case FormatType::kR8G8B8A8_SNORM:
+      ret = VK_FORMAT_R8G8B8A8_SNORM;
+      break;
+    case FormatType::kR8G8B8A8_SRGB:
+      ret = VK_FORMAT_R8G8B8A8_SRGB;
+      break;
+    case FormatType::kR8G8B8A8_SSCALED:
+      ret = VK_FORMAT_R8G8B8A8_SSCALED;
+      break;
+    case FormatType::kR8G8B8A8_UINT:
+      ret = VK_FORMAT_R8G8B8A8_UINT;
+      break;
+    case FormatType::kR8G8B8A8_UNORM:
+      ret = VK_FORMAT_R8G8B8A8_UNORM;
+      break;
+    case FormatType::kR8G8B8A8_USCALED:
+      ret = VK_FORMAT_R8G8B8A8_USCALED;
+      break;
+    case FormatType::kR8G8B8_SINT:
+      ret = VK_FORMAT_R8G8B8_SINT;
+      break;
+    case FormatType::kR8G8B8_SNORM:
+      ret = VK_FORMAT_R8G8B8_SNORM;
+      break;
+    case FormatType::kR8G8B8_SRGB:
+      ret = VK_FORMAT_R8G8B8_SRGB;
+      break;
+    case FormatType::kR8G8B8_SSCALED:
+      ret = VK_FORMAT_R8G8B8_SSCALED;
+      break;
+    case FormatType::kR8G8B8_UINT:
+      ret = VK_FORMAT_R8G8B8_UINT;
+      break;
+    case FormatType::kR8G8B8_UNORM:
+      ret = VK_FORMAT_R8G8B8_UNORM;
+      break;
+    case FormatType::kR8G8B8_USCALED:
+      ret = VK_FORMAT_R8G8B8_USCALED;
+      break;
+    case FormatType::kR8G8_SINT:
+      ret = VK_FORMAT_R8G8_SINT;
+      break;
+    case FormatType::kR8G8_SNORM:
+      ret = VK_FORMAT_R8G8_SNORM;
+      break;
+    case FormatType::kR8G8_SRGB:
+      ret = VK_FORMAT_R8G8_SRGB;
+      break;
+    case FormatType::kR8G8_SSCALED:
+      ret = VK_FORMAT_R8G8_SSCALED;
+      break;
+    case FormatType::kR8G8_UINT:
+      ret = VK_FORMAT_R8G8_UINT;
+      break;
+    case FormatType::kR8G8_UNORM:
+      ret = VK_FORMAT_R8G8_UNORM;
+      break;
+    case FormatType::kR8G8_USCALED:
+      ret = VK_FORMAT_R8G8_USCALED;
+      break;
+    case FormatType::kR8_SINT:
+      ret = VK_FORMAT_R8_SINT;
+      break;
+    case FormatType::kR8_SNORM:
+      ret = VK_FORMAT_R8_SNORM;
+      break;
+    case FormatType::kR8_SRGB:
+      ret = VK_FORMAT_R8_SRGB;
+      break;
+    case FormatType::kR8_SSCALED:
+      ret = VK_FORMAT_R8_SSCALED;
+      break;
+    case FormatType::kR8_UINT:
+      ret = VK_FORMAT_R8_UINT;
+      break;
+    case FormatType::kR8_UNORM:
+      ret = VK_FORMAT_R8_UNORM;
+      break;
+    case FormatType::kR8_USCALED:
+      ret = VK_FORMAT_R8_USCALED;
+      break;
+    case FormatType::kS8_UINT:
+      ret = VK_FORMAT_S8_UINT;
+      break;
+    case FormatType::kX8_D24_UNORM_PACK32:
+      ret = VK_FORMAT_X8_D24_UNORM_PACK32;
+      break;
+  }
+  return ret;
+}
+
 }  // namespace vulkan
 }  // namespace amber
diff --git a/src/vulkan/device.h b/src/vulkan/device.h
index 8f9d9dc..e55bf88 100644
--- a/src/vulkan/device.h
+++ b/src/vulkan/device.h
@@ -54,6 +54,7 @@ class Device {
 
   VkDevice GetVkDevice() const { return device_; }
   VkQueue GetVkQueue() const { return queue_; }
+  VkFormat GetVkFormat(const Format& format) const;
 
   uint32_t GetQueueFamilyIndex() const { return queue_family_index_; }
   uint32_t GetMaxPushConstants() const;
diff --git a/src/vulkan/engine_vulkan.cc b/src/vulkan/engine_vulkan.cc
index a94dba7..33eb9d5 100644
--- a/src/vulkan/engine_vulkan.cc
+++ b/src/vulkan/engine_vulkan.cc
@@ -21,7 +21,6 @@
 #include "amber/amber_vulkan.h"
 #include "src/make_unique.h"
 #include "src/vulkan/compute_pipeline.h"
-#include "src/vulkan/format_data.h"
 #include "src/vulkan/graphics_pipeline.h"
 
 namespace amber {
@@ -155,15 +154,14 @@ Result EngineVulkan::CreatePipeline(amber::Pipeline* pipeline) {
     }
   }
 
-  FormatType depth_buffer_format = FormatType::kUnknown;
+  Format depth_fmt;
   if (pipeline->GetDepthBuffer().buffer) {
     const auto& depth_info = pipeline->GetDepthBuffer();
-    auto& depth_fmt = depth_info.buffer->AsFormatBuffer()->GetFormat();
+    depth_fmt = depth_info.buffer->AsFormatBuffer()->GetFormat();
     if (!device_->IsFormatSupportedByPhysicalDevice(
-            depth_fmt, depth_info.buffer->GetBufferType()))
+            depth_fmt, depth_info.buffer->GetBufferType())) {
       return Result("Vulkan depth attachment format is not supported");
-
-    depth_buffer_format = depth_fmt.GetFormatType();
+    }
   }
 
   std::vector<VkPipelineShaderStageCreateInfo> stage_create_info;
@@ -181,9 +179,8 @@ Result EngineVulkan::CreatePipeline(amber::Pipeline* pipeline) {
       return r;
   } else {
     vk_pipeline = MakeUnique<GraphicsPipeline>(
-        device_.get(), pipeline->GetColorAttachments(),
-        ToVkFormat(depth_buffer_format), engine_data.fence_timeout_ms,
-        stage_create_info);
+        device_.get(), pipeline->GetColorAttachments(), depth_fmt,
+        engine_data.fence_timeout_ms, stage_create_info);
 
     r = vk_pipeline->AsGraphics()->Initialize(pipeline->GetFramebufferWidth(),
                                               pipeline->GetFramebufferHeight(),
diff --git a/src/vulkan/format_data.cc b/src/vulkan/format_data.cc
deleted file mode 100644
index 03220dc..0000000
--- a/src/vulkan/format_data.cc
+++ /dev/null
@@ -1,572 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/vulkan/format_data.h"
-
-namespace amber {
-namespace vulkan {
-
-VkFormat ToVkFormat(FormatType type) {
-  VkFormat ret = VK_FORMAT_UNDEFINED;
-  switch (type) {
-    case FormatType::kUnknown:
-      ret = VK_FORMAT_UNDEFINED;
-      break;
-    case FormatType::kA1R5G5B5_UNORM_PACK16:
-      ret = VK_FORMAT_A1R5G5B5_UNORM_PACK16;
-      break;
-    case FormatType::kA2B10G10R10_SINT_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_SINT_PACK32;
-      break;
-    case FormatType::kA2B10G10R10_SNORM_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_SNORM_PACK32;
-      break;
-    case FormatType::kA2B10G10R10_SSCALED_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
-      break;
-    case FormatType::kA2B10G10R10_UINT_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_UINT_PACK32;
-      break;
-    case FormatType::kA2B10G10R10_UNORM_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
-      break;
-    case FormatType::kA2B10G10R10_USCALED_PACK32:
-      ret = VK_FORMAT_A2B10G10R10_USCALED_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_SINT_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_SINT_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_SNORM_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_SNORM_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_SSCALED_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_SSCALED_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_UINT_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_UINT_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_UNORM_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_UNORM_PACK32;
-      break;
-    case FormatType::kA2R10G10B10_USCALED_PACK32:
-      ret = VK_FORMAT_A2R10G10B10_USCALED_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_SINT_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_SINT_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_SNORM_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_SNORM_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_SRGB_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_SRGB_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_SSCALED_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_SSCALED_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_UINT_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_UINT_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_UNORM_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
-      break;
-    case FormatType::kA8B8G8R8_USCALED_PACK32:
-      ret = VK_FORMAT_A8B8G8R8_USCALED_PACK32;
-      break;
-    case FormatType::kB10G11R11_UFLOAT_PACK32:
-      ret = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
-      break;
-    case FormatType::kB4G4R4A4_UNORM_PACK16:
-      ret = VK_FORMAT_B4G4R4A4_UNORM_PACK16;
-      break;
-    case FormatType::kB5G5R5A1_UNORM_PACK16:
-      ret = VK_FORMAT_B5G5R5A1_UNORM_PACK16;
-      break;
-    case FormatType::kB5G6R5_UNORM_PACK16:
-      ret = VK_FORMAT_B5G6R5_UNORM_PACK16;
-      break;
-    case FormatType::kB8G8R8A8_SINT:
-      ret = VK_FORMAT_B8G8R8A8_SINT;
-      break;
-    case FormatType::kB8G8R8A8_SNORM:
-      ret = VK_FORMAT_B8G8R8A8_SNORM;
-      break;
-    case FormatType::kB8G8R8A8_SRGB:
-      ret = VK_FORMAT_B8G8R8A8_SRGB;
-      break;
-    case FormatType::kB8G8R8A8_SSCALED:
-      ret = VK_FORMAT_B8G8R8A8_SSCALED;
-      break;
-    case FormatType::kB8G8R8A8_UINT:
-      ret = VK_FORMAT_B8G8R8A8_UINT;
-      break;
-    case FormatType::kB8G8R8A8_UNORM:
-      ret = VK_FORMAT_B8G8R8A8_UNORM;
-      break;
-    case FormatType::kB8G8R8A8_USCALED:
-      ret = VK_FORMAT_B8G8R8A8_USCALED;
-      break;
-    case FormatType::kB8G8R8_SINT:
-      ret = VK_FORMAT_B8G8R8_SINT;
-      break;
-    case FormatType::kB8G8R8_SNORM:
-      ret = VK_FORMAT_B8G8R8_SNORM;
-      break;
-    case FormatType::kB8G8R8_SRGB:
-      ret = VK_FORMAT_B8G8R8_SRGB;
-      break;
-    case FormatType::kB8G8R8_SSCALED:
-      ret = VK_FORMAT_B8G8R8_SSCALED;
-      break;
-    case FormatType::kB8G8R8_UINT:
-      ret = VK_FORMAT_B8G8R8_UINT;
-      break;
-    case FormatType::kB8G8R8_UNORM:
-      ret = VK_FORMAT_B8G8R8_UNORM;
-      break;
-    case FormatType::kB8G8R8_USCALED:
-      ret = VK_FORMAT_B8G8R8_USCALED;
-      break;
-    case FormatType::kD16_UNORM:
-      ret = VK_FORMAT_D16_UNORM;
-      break;
-    case FormatType::kD16_UNORM_S8_UINT:
-      ret = VK_FORMAT_D16_UNORM_S8_UINT;
-      break;
-    case FormatType::kD24_UNORM_S8_UINT:
-      ret = VK_FORMAT_D24_UNORM_S8_UINT;
-      break;
-    case FormatType::kD32_SFLOAT:
-      ret = VK_FORMAT_D32_SFLOAT;
-      break;
-    case FormatType::kD32_SFLOAT_S8_UINT:
-      ret = VK_FORMAT_D32_SFLOAT_S8_UINT;
-      break;
-    case FormatType::kR16G16B16A16_SFLOAT:
-      ret = VK_FORMAT_R16G16B16A16_SFLOAT;
-      break;
-    case FormatType::kR16G16B16A16_SINT:
-      ret = VK_FORMAT_R16G16B16A16_SINT;
-      break;
-    case FormatType::kR16G16B16A16_SNORM:
-      ret = VK_FORMAT_R16G16B16A16_SNORM;
-      break;
-    case FormatType::kR16G16B16A16_SSCALED:
-      ret = VK_FORMAT_R16G16B16A16_SSCALED;
-      break;
-    case FormatType::kR16G16B16A16_UINT:
-      ret = VK_FORMAT_R16G16B16A16_UINT;
-      break;
-    case FormatType::kR16G16B16A16_UNORM:
-      ret = VK_FORMAT_R16G16B16A16_UNORM;
-      break;
-    case FormatType::kR16G16B16A16_USCALED:
-      ret = VK_FORMAT_R16G16B16A16_USCALED;
-      break;
-    case FormatType::kR16G16B16_SFLOAT:
-      ret = VK_FORMAT_R16G16B16_SFLOAT;
-      break;
-    case FormatType::kR16G16B16_SINT:
-      ret = VK_FORMAT_R16G16B16_SINT;
-      break;
-    case FormatType::kR16G16B16_SNORM:
-      ret = VK_FORMAT_R16G16B16_SNORM;
-      break;
-    case FormatType::kR16G16B16_SSCALED:
-      ret = VK_FORMAT_R16G16B16_SSCALED;
-      break;
-    case FormatType::kR16G16B16_UINT:
-      ret = VK_FORMAT_R16G16B16_UINT;
-      break;
-    case FormatType::kR16G16B16_UNORM:
-      ret = VK_FORMAT_R16G16B16_UNORM;
-      break;
-    case FormatType::kR16G16B16_USCALED:
-      ret = VK_FORMAT_R16G16B16_USCALED;
-      break;
-    case FormatType::kR16G16_SFLOAT:
-      ret = VK_FORMAT_R16G16_SFLOAT;
-      break;
-    case FormatType::kR16G16_SINT:
-      ret = VK_FORMAT_R16G16_SINT;
-      break;
-    case FormatType::kR16G16_SNORM:
-      ret = VK_FORMAT_R16G16_SNORM;
-      break;
-    case FormatType::kR16G16_SSCALED:
-      ret = VK_FORMAT_R16G16_SSCALED;
-      break;
-    case FormatType::kR16G16_UINT:
-      ret = VK_FORMAT_R16G16_UINT;
-      break;
-    case FormatType::kR16G16_UNORM:
-      ret = VK_FORMAT_R16G16_UNORM;
-      break;
-    case FormatType::kR16G16_USCALED:
-      ret = VK_FORMAT_R16G16_USCALED;
-      break;
-    case FormatType::kR16_SFLOAT:
-      ret = VK_FORMAT_R16_SFLOAT;
-      break;
-    case FormatType::kR16_SINT:
-      ret = VK_FORMAT_R16_SINT;
-      break;
-    case FormatType::kR16_SNORM:
-      ret = VK_FORMAT_R16_SNORM;
-      break;
-    case FormatType::kR16_SSCALED:
-      ret = VK_FORMAT_R16_SSCALED;
-      break;
-    case FormatType::kR16_UINT:
-      ret = VK_FORMAT_R16_UINT;
-      break;
-    case FormatType::kR16_UNORM:
-      ret = VK_FORMAT_R16_UNORM;
-      break;
-    case FormatType::kR16_USCALED:
-      ret = VK_FORMAT_R16_USCALED;
-      break;
-    case FormatType::kR32G32B32A32_SFLOAT:
-      ret = VK_FORMAT_R32G32B32A32_SFLOAT;
-      break;
-    case FormatType::kR32G32B32A32_SINT:
-      ret = VK_FORMAT_R32G32B32A32_SINT;
-      break;
-    case FormatType::kR32G32B32A32_UINT:
-      ret = VK_FORMAT_R32G32B32A32_UINT;
-      break;
-    case FormatType::kR32G32B32_SFLOAT:
-      ret = VK_FORMAT_R32G32B32_SFLOAT;
-      break;
-    case FormatType::kR32G32B32_SINT:
-      ret = VK_FORMAT_R32G32B32_SINT;
-      break;
-    case FormatType::kR32G32B32_UINT:
-      ret = VK_FORMAT_R32G32B32_UINT;
-      break;
-    case FormatType::kR32G32_SFLOAT:
-      ret = VK_FORMAT_R32G32_SFLOAT;
-      break;
-    case FormatType::kR32G32_SINT:
-      ret = VK_FORMAT_R32G32_SINT;
-      break;
-    case FormatType::kR32G32_UINT:
-      ret = VK_FORMAT_R32G32_UINT;
-      break;
-    case FormatType::kR32_SFLOAT:
-      ret = VK_FORMAT_R32_SFLOAT;
-      break;
-    case FormatType::kR32_SINT:
-      ret = VK_FORMAT_R32_SINT;
-      break;
-    case FormatType::kR32_UINT:
-      ret = VK_FORMAT_R32_UINT;
-      break;
-    case FormatType::kR4G4B4A4_UNORM_PACK16:
-      ret = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
-      break;
-    case FormatType::kR4G4_UNORM_PACK8:
-      ret = VK_FORMAT_R4G4_UNORM_PACK8;
-      break;
-    case FormatType::kR5G5B5A1_UNORM_PACK16:
-      ret = VK_FORMAT_R5G5B5A1_UNORM_PACK16;
-      break;
-    case FormatType::kR5G6B5_UNORM_PACK16:
-      ret = VK_FORMAT_R5G6B5_UNORM_PACK16;
-      break;
-    case FormatType::kR64G64B64A64_SFLOAT:
-      ret = VK_FORMAT_R64G64B64A64_SFLOAT;
-      break;
-    case FormatType::kR64G64B64A64_SINT:
-      ret = VK_FORMAT_R64G64B64A64_SINT;
-      break;
-    case FormatType::kR64G64B64A64_UINT:
-      ret = VK_FORMAT_R64G64B64A64_UINT;
-      break;
-    case FormatType::kR64G64B64_SFLOAT:
-      ret = VK_FORMAT_R64G64B64_SFLOAT;
-      break;
-    case FormatType::kR64G64B64_SINT:
-      ret = VK_FORMAT_R64G64B64_SINT;
-      break;
-    case FormatType::kR64G64B64_UINT:
-      ret = VK_FORMAT_R64G64B64_UINT;
-      break;
-    case FormatType::kR64G64_SFLOAT:
-      ret = VK_FORMAT_R64G64_SFLOAT;
-      break;
-    case FormatType::kR64G64_SINT:
-      ret = VK_FORMAT_R64G64_SINT;
-      break;
-    case FormatType::kR64G64_UINT:
-      ret = VK_FORMAT_R64G64_UINT;
-      break;
-    case FormatType::kR64_SFLOAT:
-      ret = VK_FORMAT_R64_SFLOAT;
-      break;
-    case FormatType::kR64_SINT:
-      ret = VK_FORMAT_R64_SINT;
-      break;
-    case FormatType::kR64_UINT:
-      ret = VK_FORMAT_R64_UINT;
-      break;
-    case FormatType::kR8G8B8A8_SINT:
-      ret = VK_FORMAT_R8G8B8A8_SINT;
-      break;
-    case FormatType::kR8G8B8A8_SNORM:
-      ret = VK_FORMAT_R8G8B8A8_SNORM;
-      break;
-    case FormatType::kR8G8B8A8_SRGB:
-      ret = VK_FORMAT_R8G8B8A8_SRGB;
-      break;
-    case FormatType::kR8G8B8A8_SSCALED:
-      ret = VK_FORMAT_R8G8B8A8_SSCALED;
-      break;
-    case FormatType::kR8G8B8A8_UINT:
-      ret = VK_FORMAT_R8G8B8A8_UINT;
-      break;
-    case FormatType::kR8G8B8A8_UNORM:
-      ret = VK_FORMAT_R8G8B8A8_UNORM;
-      break;
-    case FormatType::kR8G8B8A8_USCALED:
-      ret = VK_FORMAT_R8G8B8A8_USCALED;
-      break;
-    case FormatType::kR8G8B8_SINT:
-      ret = VK_FORMAT_R8G8B8_SINT;
-      break;
-    case FormatType::kR8G8B8_SNORM:
-      ret = VK_FORMAT_R8G8B8_SNORM;
-      break;
-    case FormatType::kR8G8B8_SRGB:
-      ret = VK_FORMAT_R8G8B8_SRGB;
-      break;
-    case FormatType::kR8G8B8_SSCALED:
-      ret = VK_FORMAT_R8G8B8_SSCALED;
-      break;
-    case FormatType::kR8G8B8_UINT:
-      ret = VK_FORMAT_R8G8B8_UINT;
-      break;
-    case FormatType::kR8G8B8_UNORM:
-      ret = VK_FORMAT_R8G8B8_UNORM;
-      break;
-    case FormatType::kR8G8B8_USCALED:
-      ret = VK_FORMAT_R8G8B8_USCALED;
-      break;
-    case FormatType::kR8G8_SINT:
-      ret = VK_FORMAT_R8G8_SINT;
-      break;
-    case FormatType::kR8G8_SNORM:
-      ret = VK_FORMAT_R8G8_SNORM;
-      break;
-    case FormatType::kR8G8_SRGB:
-      ret = VK_FORMAT_R8G8_SRGB;
-      break;
-    case FormatType::kR8G8_SSCALED:
-      ret = VK_FORMAT_R8G8_SSCALED;
-      break;
-    case FormatType::kR8G8_UINT:
-      ret = VK_FORMAT_R8G8_UINT;
-      break;
-    case FormatType::kR8G8_UNORM:
-      ret = VK_FORMAT_R8G8_UNORM;
-      break;
-    case FormatType::kR8G8_USCALED:
-      ret = VK_FORMAT_R8G8_USCALED;
-      break;
-    case FormatType::kR8_SINT:
-      ret = VK_FORMAT_R8_SINT;
-      break;
-    case FormatType::kR8_SNORM:
-      ret = VK_FORMAT_R8_SNORM;
-      break;
-    case FormatType::kR8_SRGB:
-      ret = VK_FORMAT_R8_SRGB;
-      break;
-    case FormatType::kR8_SSCALED:
-      ret = VK_FORMAT_R8_SSCALED;
-      break;
-    case FormatType::kR8_UINT:
-      ret = VK_FORMAT_R8_UINT;
-      break;
-    case FormatType::kR8_UNORM:
-      ret = VK_FORMAT_R8_UNORM;
-      break;
-    case FormatType::kR8_USCALED:
-      ret = VK_FORMAT_R8_USCALED;
-      break;
-    case FormatType::kS8_UINT:
-      ret = VK_FORMAT_S8_UINT;
-      break;
-    case FormatType::kX8_D24_UNORM_PACK32:
-      ret = VK_FORMAT_X8_D24_UNORM_PACK32;
-      break;
-  }
-  return ret;
-}
-
-uint32_t VkFormatToByteSize(VkFormat format) {
-  switch (format) {
-    case VK_FORMAT_R4G4_UNORM_PACK8:
-    case VK_FORMAT_R8_SINT:
-    case VK_FORMAT_R8_SNORM:
-    case VK_FORMAT_R8_SRGB:
-    case VK_FORMAT_R8_SSCALED:
-    case VK_FORMAT_R8_UINT:
-    case VK_FORMAT_R8_UNORM:
-    case VK_FORMAT_R8_USCALED:
-    case VK_FORMAT_S8_UINT:
-      return 1U;
-    case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-    case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
-    case VK_FORMAT_B5G6R5_UNORM_PACK16:
-    case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-    case VK_FORMAT_D16_UNORM:
-    case VK_FORMAT_R16_SFLOAT:
-    case VK_FORMAT_R16_SINT:
-    case VK_FORMAT_R16_SNORM:
-    case VK_FORMAT_R16_SSCALED:
-    case VK_FORMAT_R16_UINT:
-    case VK_FORMAT_R16_UNORM:
-    case VK_FORMAT_R16_USCALED:
-    case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
-    case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
-    case VK_FORMAT_R5G6B5_UNORM_PACK16:
-    case VK_FORMAT_R8G8_SINT:
-    case VK_FORMAT_R8G8_SNORM:
-    case VK_FORMAT_R8G8_SRGB:
-    case VK_FORMAT_R8G8_SSCALED:
-    case VK_FORMAT_R8G8_UINT:
-    case VK_FORMAT_R8G8_UNORM:
-    case VK_FORMAT_R8G8_USCALED:
-      return 2U;
-    case VK_FORMAT_B8G8R8_SINT:
-    case VK_FORMAT_B8G8R8_SNORM:
-    case VK_FORMAT_B8G8R8_SRGB:
-    case VK_FORMAT_B8G8R8_SSCALED:
-    case VK_FORMAT_B8G8R8_UINT:
-    case VK_FORMAT_B8G8R8_UNORM:
-    case VK_FORMAT_B8G8R8_USCALED:
-    case VK_FORMAT_D16_UNORM_S8_UINT:
-    case VK_FORMAT_R8G8B8_SINT:
-    case VK_FORMAT_R8G8B8_SNORM:
-    case VK_FORMAT_R8G8B8_SRGB:
-    case VK_FORMAT_R8G8B8_SSCALED:
-    case VK_FORMAT_R8G8B8_UINT:
-    case VK_FORMAT_R8G8B8_UNORM:
-    case VK_FORMAT_R8G8B8_USCALED:
-      return 3U;
-    case VK_FORMAT_A2B10G10R10_SINT_PACK32:
-    case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
-    case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
-    case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-    case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
-    case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
-    case VK_FORMAT_A2R10G10B10_SINT_PACK32:
-    case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
-    case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
-    case VK_FORMAT_A2R10G10B10_UINT_PACK32:
-    case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
-    case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
-    case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-    case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
-    case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
-    case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
-    case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-    case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
-    case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
-    case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
-    case VK_FORMAT_B8G8R8A8_SINT:
-    case VK_FORMAT_B8G8R8A8_SNORM:
-    case VK_FORMAT_B8G8R8A8_SRGB:
-    case VK_FORMAT_B8G8R8A8_SSCALED:
-    case VK_FORMAT_B8G8R8A8_UINT:
-    case VK_FORMAT_B8G8R8A8_UNORM:
-    case VK_FORMAT_B8G8R8A8_USCALED:
-    case VK_FORMAT_D24_UNORM_S8_UINT:
-    case VK_FORMAT_D32_SFLOAT:
-    case VK_FORMAT_R16G16_SFLOAT:
-    case VK_FORMAT_R16G16_SINT:
-    case VK_FORMAT_R16G16_SNORM:
-    case VK_FORMAT_R16G16_SSCALED:
-    case VK_FORMAT_R16G16_UINT:
-    case VK_FORMAT_R16G16_UNORM:
-    case VK_FORMAT_R16G16_USCALED:
-    case VK_FORMAT_R32_SFLOAT:
-    case VK_FORMAT_R32_SINT:
-    case VK_FORMAT_R32_UINT:
-    case VK_FORMAT_X8_D24_UNORM_PACK32:
-    case VK_FORMAT_R8G8B8A8_SINT:
-    case VK_FORMAT_R8G8B8A8_SNORM:
-    case VK_FORMAT_R8G8B8A8_SRGB:
-    case VK_FORMAT_R8G8B8A8_SSCALED:
-    case VK_FORMAT_R8G8B8A8_UINT:
-    case VK_FORMAT_R8G8B8A8_UNORM:
-    case VK_FORMAT_R8G8B8A8_USCALED:
-      return 4U;
-    case VK_FORMAT_D32_SFLOAT_S8_UINT:
-      return 5U;
-    case VK_FORMAT_R16G16B16_SFLOAT:
-    case VK_FORMAT_R16G16B16_SINT:
-    case VK_FORMAT_R16G16B16_SNORM:
-    case VK_FORMAT_R16G16B16_SSCALED:
-    case VK_FORMAT_R16G16B16_UINT:
-    case VK_FORMAT_R16G16B16_UNORM:
-    case VK_FORMAT_R16G16B16_USCALED:
-      return 6U;
-    case VK_FORMAT_R16G16B16A16_SFLOAT:
-    case VK_FORMAT_R16G16B16A16_SINT:
-    case VK_FORMAT_R16G16B16A16_SNORM:
-    case VK_FORMAT_R16G16B16A16_SSCALED:
-    case VK_FORMAT_R16G16B16A16_UINT:
-    case VK_FORMAT_R16G16B16A16_UNORM:
-    case VK_FORMAT_R16G16B16A16_USCALED:
-    case VK_FORMAT_R32G32_SFLOAT:
-    case VK_FORMAT_R32G32_SINT:
-    case VK_FORMAT_R32G32_UINT:
-    case VK_FORMAT_R64_SFLOAT:
-    case VK_FORMAT_R64_SINT:
-    case VK_FORMAT_R64_UINT:
-      return 8U;
-    case VK_FORMAT_R32G32B32_SFLOAT:
-    case VK_FORMAT_R32G32B32_SINT:
-    case VK_FORMAT_R32G32B32_UINT:
-      return 12U;
-    case VK_FORMAT_R32G32B32A32_SFLOAT:
-    case VK_FORMAT_R32G32B32A32_SINT:
-    case VK_FORMAT_R32G32B32A32_UINT:
-    case VK_FORMAT_R64G64_SFLOAT:
-    case VK_FORMAT_R64G64_SINT:
-    case VK_FORMAT_R64G64_UINT:
-      return 16U;
-    case VK_FORMAT_R64G64B64_SFLOAT:
-    case VK_FORMAT_R64G64B64_SINT:
-    case VK_FORMAT_R64G64B64_UINT:
-      return 24U;
-    case VK_FORMAT_R64G64B64A64_SFLOAT:
-    case VK_FORMAT_R64G64B64A64_SINT:
-    case VK_FORMAT_R64G64B64A64_UINT:
-      return 32U;
-    default:
-      break;
-  }
-  return 0;
-}
-
-bool VkFormatHasStencilComponent(VkFormat format) {
-  return format == VK_FORMAT_D24_UNORM_S8_UINT ||
-         format == VK_FORMAT_D16_UNORM_S8_UINT ||
-         format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_S8_UINT;
-}
-
-}  // namespace vulkan
-}  // namespace amber
diff --git a/src/vulkan/format_data.h b/src/vulkan/format_data.h
deleted file mode 100644
index 85ba6ba..0000000
--- a/src/vulkan/format_data.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_VULKAN_FORMAT_DATA_H_
-#define SRC_VULKAN_FORMAT_DATA_H_
-
-#include <cstdint>
-
-#include "amber/vulkan_header.h"
-#include "src/format_data.h"
-
-namespace amber {
-namespace vulkan {
-
-VkFormat ToVkFormat(FormatType type);
-uint32_t VkFormatToByteSize(VkFormat format);
-bool VkFormatHasStencilComponent(VkFormat format);
-
-}  // namespace vulkan
-}  // namespace amber
-
-#endif  // SRC_VULKAN_FORMAT_DATA_H_
diff --git a/src/vulkan/frame_buffer.cc b/src/vulkan/frame_buffer.cc
index 308e622..33be51c 100644
--- a/src/vulkan/frame_buffer.cc
+++ b/src/vulkan/frame_buffer.cc
@@ -22,7 +22,6 @@
 #include "src/make_unique.h"
 #include "src/vulkan/command_buffer.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
@@ -45,7 +44,7 @@ FrameBuffer::~FrameBuffer() {
 }
 
 Result FrameBuffer::Initialize(VkRenderPass render_pass,
-                               VkFormat depth_format) {
+                               const Format& depth_format) {
   std::vector<VkImageView> attachments;
 
   if (!color_attachments_.empty()) {
@@ -63,9 +62,7 @@ Result FrameBuffer::Initialize(VkRenderPass render_pass,
     attachments.resize(color_attachments_.size());
     for (auto* info : color_attachments_) {
       color_images_.push_back(MakeUnique<TransferImage>(
-          device_,
-          ToVkFormat(
-              info->buffer->AsFormatBuffer()->GetFormat().GetFormatType()),
+          device_, info->buffer->AsFormatBuffer()->GetFormat(),
           VK_IMAGE_ASPECT_COLOR_BIT, width_, height_, depth_));
 
       Result r =
@@ -78,13 +75,13 @@ Result FrameBuffer::Initialize(VkRenderPass render_pass,
     }
   }
 
-  if (depth_format != VK_FORMAT_UNDEFINED) {
+  if (depth_format.IsFormatKnown()) {
     depth_image_ = MakeUnique<TransferImage>(
         device_, depth_format,
-        static_cast<VkImageAspectFlags>(
-            VkFormatHasStencilComponent(depth_format)
-                ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT
-                : VK_IMAGE_ASPECT_DEPTH_BIT),
+        static_cast<VkImageAspectFlags>(depth_format.HasStencilComponent()
+                                            ? VK_IMAGE_ASPECT_DEPTH_BIT |
+                                                  VK_IMAGE_ASPECT_STENCIL_BIT
+                                            : VK_IMAGE_ASPECT_DEPTH_BIT),
         width_, height_, depth_);
 
     Result r =
diff --git a/src/vulkan/frame_buffer.h b/src/vulkan/frame_buffer.h
index 7995163..2f21c73 100644
--- a/src/vulkan/frame_buffer.h
+++ b/src/vulkan/frame_buffer.h
@@ -42,7 +42,7 @@ class FrameBuffer {
       uint32_t height);
   ~FrameBuffer();
 
-  Result Initialize(VkRenderPass render_pass, VkFormat depth_format);
+  Result Initialize(VkRenderPass render_pass, const Format& depth_format);
 
   Result ChangeFrameImageLayout(CommandBuffer* command, FrameImageState layout);
 
diff --git a/src/vulkan/graphics_pipeline.cc b/src/vulkan/graphics_pipeline.cc
index a9db294..b3176bb 100644
--- a/src/vulkan/graphics_pipeline.cc
+++ b/src/vulkan/graphics_pipeline.cc
@@ -21,7 +21,6 @@
 #include "src/make_unique.h"
 #include "src/vulkan/command_pool.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
@@ -349,7 +348,7 @@ VkBlendOp ToVkBlendOp(BlendOp op) {
 class RenderPassGuard {
  public:
   explicit RenderPassGuard(GraphicsPipeline* pipeline) : pipeline_(pipeline) {
-    auto* frame = pipeline->GetFrame();
+    auto* frame = pipeline->GetFrameBuffer();
     auto* cmd = pipeline->GetCommandBuffer();
     result_ = frame->ChangeFrameImageLayout(cmd, FrameImageState::kClearOrDraw);
     if (!result_.IsSuccess())
@@ -386,7 +385,7 @@ class RenderPassGuard {
 GraphicsPipeline::GraphicsPipeline(
     Device* device,
     const std::vector<amber::Pipeline::BufferInfo>& color_buffers,
-    VkFormat depth_stencil_format,
+    const Format& depth_stencil_format,
     uint32_t fence_timeout_ms,
     const std::vector<VkPipelineShaderStageCreateInfo>& shader_stage_info)
     : Pipeline(PipelineType::kGraphics,
@@ -417,7 +416,7 @@ Result GraphicsPipeline::CreateRenderPass() {
   for (const auto* info : color_buffers_) {
     attachment_desc.push_back(kDefaultAttachmentDesc);
     attachment_desc.back().format =
-        ToVkFormat(info->buffer->AsFormatBuffer()->GetFormat().GetFormatType());
+        device_->GetVkFormat(info->buffer->AsFormatBuffer()->GetFormat());
     attachment_desc.back().initialLayout =
         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
     attachment_desc.back().finalLayout =
@@ -433,9 +432,9 @@ Result GraphicsPipeline::CreateRenderPass() {
     subpass_desc.pColorAttachments = color_refer.data();
   }
 
-  if (depth_stencil_format_ != VK_FORMAT_UNDEFINED) {
+  if (depth_stencil_format_.IsFormatKnown()) {
     attachment_desc.push_back(kDefaultAttachmentDesc);
-    attachment_desc.back().format = depth_stencil_format_;
+    attachment_desc.back().format = device_->GetVkFormat(depth_stencil_format_);
     attachment_desc.back().initialLayout =
         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     attachment_desc.back().finalLayout =
@@ -651,7 +650,7 @@ Result GraphicsPipeline::CreateVkGraphicsPipeline(
   }
 
   VkPipelineDepthStencilStateCreateInfo depthstencil_info;
-  if (depth_stencil_format_ != VK_FORMAT_UNDEFINED) {
+  if (depth_stencil_format_.IsFormatKnown()) {
     depthstencil_info = GetVkPipelineDepthStencilInfo(pipeline_data);
     pipeline_info.pDepthStencilState = &depthstencil_info;
   }
@@ -741,7 +740,7 @@ Result GraphicsPipeline::SetClearColor(float r, float g, float b, float a) {
 }
 
 Result GraphicsPipeline::SetClearStencil(uint32_t stencil) {
-  if (depth_stencil_format_ == VK_FORMAT_UNDEFINED) {
+  if (!depth_stencil_format_.IsFormatKnown()) {
     return Result(
         "Vulkan::ClearStencilCommand No DepthStencil Buffer for FrameBuffer "
         "Exists");
@@ -752,7 +751,7 @@ Result GraphicsPipeline::SetClearStencil(uint32_t stencil) {
 }
 
 Result GraphicsPipeline::SetClearDepth(float depth) {
-  if (depth_stencil_format_ == VK_FORMAT_UNDEFINED) {
+  if (!depth_stencil_format_.IsFormatKnown()) {
     return Result(
         "Vulkan::ClearStencilCommand No DepthStencil Buffer for FrameBuffer "
         "Exists");
@@ -771,14 +770,14 @@ Result GraphicsPipeline::Clear() {
   if (!r.IsSuccess())
     return r;
 
-  if (depth_stencil_format_ == VK_FORMAT_UNDEFINED)
+  if (!depth_stencil_format_.IsFormatKnown())
     return {};
 
   VkClearValue depth_clear;
   depth_clear.depthStencil = {clear_depth_, clear_stencil_};
 
   return ClearBuffer(
-      depth_clear, VkFormatHasStencilComponent(depth_stencil_format_)
+      depth_clear, depth_stencil_format_.HasStencilComponent()
                        ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT
                        : VK_IMAGE_ASPECT_DEPTH_BIT);
 }
diff --git a/src/vulkan/graphics_pipeline.h b/src/vulkan/graphics_pipeline.h
index 58d5dca..fa84948 100644
--- a/src/vulkan/graphics_pipeline.h
+++ b/src/vulkan/graphics_pipeline.h
@@ -42,7 +42,7 @@ class GraphicsPipeline : public Pipeline {
   GraphicsPipeline(
       Device* device,
       const std::vector<amber::Pipeline::BufferInfo>& color_buffers,
-      VkFormat depth_stencil_format,
+      const Format& depth_stencil_format,
       uint32_t fence_timeout_ms,
       const std::vector<VkPipelineShaderStageCreateInfo>&);
   ~GraphicsPipeline() override;
@@ -62,7 +62,7 @@ class GraphicsPipeline : public Pipeline {
   Result Draw(const DrawArraysCommand* command, VertexBuffer* vertex_buffer);
 
   VkRenderPass GetVkRenderPass() const { return render_pass_; }
-  FrameBuffer* GetFrame() const { return frame_.get(); }
+  FrameBuffer* GetFrameBuffer() const { return frame_.get(); }
 
   uint32_t GetWidth() const { return frame_width_; }
   uint32_t GetHeight() const { return frame_height_; }
@@ -101,7 +101,7 @@ class GraphicsPipeline : public Pipeline {
 
   // color buffers are owned by the amber::Pipeline.
   std::vector<const amber::Pipeline::BufferInfo*> color_buffers_;
-  VkFormat depth_stencil_format_;
+  Format depth_stencil_format_;
   std::unique_ptr<IndexBuffer> index_buffer_;
 
   uint32_t frame_width_ = 0;
diff --git a/src/vulkan/index_buffer.cc b/src/vulkan/index_buffer.cc
index 4293471..625a18b 100644
--- a/src/vulkan/index_buffer.cc
+++ b/src/vulkan/index_buffer.cc
@@ -19,7 +19,6 @@
 #include "src/make_unique.h"
 #include "src/vulkan/command_buffer.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
diff --git a/src/vulkan/resource.cc b/src/vulkan/resource.cc
index 4d93e35..e90e7c1 100644
--- a/src/vulkan/resource.cc
+++ b/src/vulkan/resource.cc
@@ -19,7 +19,6 @@
 #include "src/make_unique.h"
 #include "src/vulkan/command_buffer.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
diff --git a/src/vulkan/transfer_image.cc b/src/vulkan/transfer_image.cc
index 40d44aa..60f29a3 100644
--- a/src/vulkan/transfer_image.cc
+++ b/src/vulkan/transfer_image.cc
@@ -18,7 +18,6 @@
 
 #include "src/vulkan/command_buffer.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
@@ -46,15 +45,15 @@ const VkImageCreateInfo kDefaultImageInfo = {
 }  // namespace
 
 TransferImage::TransferImage(Device* device,
-                             VkFormat format,
+                             const Format& format,
                              VkImageAspectFlags aspect,
                              uint32_t x,
                              uint32_t y,
                              uint32_t z)
-    : Resource(device, x * y * z * VkFormatToByteSize(format)),
+    : Resource(device, x * y * z * format.GetByteSize()),
       image_info_(kDefaultImageInfo),
       aspect_(aspect) {
-  image_info_.format = format;
+  image_info_.format = device_->GetVkFormat(format);
   image_info_.extent = {x, y, z};
 }
 
diff --git a/src/vulkan/transfer_image.h b/src/vulkan/transfer_image.h
index df70c00..a1cac08 100644
--- a/src/vulkan/transfer_image.h
+++ b/src/vulkan/transfer_image.h
@@ -17,6 +17,7 @@
 
 #include "amber/result.h"
 #include "amber/vulkan_header.h"
+#include "src/format.h"
 #include "src/vulkan/resource.h"
 
 namespace amber {
@@ -28,7 +29,7 @@ class Device;
 class TransferImage : public Resource {
  public:
   TransferImage(Device* device,
-                VkFormat format,
+                const Format& format,
                 VkImageAspectFlags aspect,
                 uint32_t x,
                 uint32_t y,
diff --git a/src/vulkan/vertex_buffer.cc b/src/vulkan/vertex_buffer.cc
index 5df65c8..9aa150b 100644
--- a/src/vulkan/vertex_buffer.cc
+++ b/src/vulkan/vertex_buffer.cc
@@ -20,7 +20,6 @@
 #include "src/make_unique.h"
 #include "src/vulkan/command_buffer.h"
 #include "src/vulkan/device.h"
-#include "src/vulkan/format_data.h"
 
 namespace amber {
 namespace vulkan {
@@ -35,8 +34,7 @@ void VertexBuffer::SetData(uint8_t location, FormatBuffer* buffer) {
   vertex_attr_desc_.back().binding = 0;
   vertex_attr_desc_.back().location = location;
   vertex_attr_desc_.back().offset = stride_in_bytes_;
-  vertex_attr_desc_.back().format =
-      ToVkFormat(buffer->GetFormat().GetFormatType());
+  vertex_attr_desc_.back().format = device_->GetVkFormat(buffer->GetFormat());
 
   stride_in_bytes_ += buffer->GetFormat().GetByteSize();
   data_.push_back(buffer);
diff --git a/src/vulkan/vertex_buffer_test.cc b/src/vulkan/vertex_buffer_test.cc
index 26e740c..a4bb7e7 100644
--- a/src/vulkan/vertex_buffer_test.cc
+++ b/src/vulkan/vertex_buffer_test.cc
@@ -97,6 +97,7 @@ TEST_F(VertexBufferTest, R8G8B8A8_UINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR8G8B8A8_UINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kUInt, 8);
   format->AddComponent(FormatComponentType::kG, FormatMode::kUInt, 8);
   format->AddComponent(FormatComponentType::kB, FormatMode::kUInt, 8);
@@ -118,6 +119,7 @@ TEST_F(VertexBufferTest, R16G16B16A16_UINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR16G16B16A16_UINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kUInt, 16);
   format->AddComponent(FormatComponentType::kG, FormatMode::kUInt, 16);
   format->AddComponent(FormatComponentType::kB, FormatMode::kUInt, 16);
@@ -139,6 +141,7 @@ TEST_F(VertexBufferTest, R32G32B32A32_UINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32B32A32_UINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kUInt, 32);
   format->AddComponent(FormatComponentType::kG, FormatMode::kUInt, 32);
   format->AddComponent(FormatComponentType::kB, FormatMode::kUInt, 32);
@@ -160,6 +163,7 @@ TEST_F(VertexBufferTest, R64G64B64A64_UINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR64G64B64A64_UINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kUInt, 64);
   format->AddComponent(FormatComponentType::kG, FormatMode::kUInt, 64);
   format->AddComponent(FormatComponentType::kB, FormatMode::kUInt, 64);
@@ -181,6 +185,7 @@ TEST_F(VertexBufferTest, R8G8B8A8_SNORM) {
   values[3].SetIntValue(127);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR8G8B8A8_SNORM);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSNorm, 8);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSNorm, 8);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSNorm, 8);
@@ -202,6 +207,7 @@ TEST_F(VertexBufferTest, R16G16B16A16_SNORM) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR16G16B16A16_SNORM);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSNorm, 16);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSNorm, 16);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSNorm, 16);
@@ -223,6 +229,7 @@ TEST_F(VertexBufferTest, R32G32B32A32_SINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32B32A32_SINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSInt, 32);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSInt, 32);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSInt, 32);
@@ -244,6 +251,7 @@ TEST_F(VertexBufferTest, R64G64B64A64_SINT) {
   values[3].SetIntValue(255);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR64G64B64A64_SINT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSInt, 64);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSInt, 64);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSInt, 64);
@@ -280,6 +288,7 @@ TEST_F(VertexBufferTest, R16G11B10_SFLOAT) {
   values[2].SetDoubleValue(0.1171875);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32_SFLOAT);  // big enough to cover.
   format->AddComponent(FormatComponentType::kR, FormatMode::kSFloat, 16);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSFloat, 11);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSFloat, 10);
@@ -312,6 +321,7 @@ TEST_F(VertexBufferTest, R10G16B11_SFLOAT) {
   values[2].SetDoubleValue(14.0);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32_SFLOAT);  // big enough to cover.
   format->AddComponent(FormatComponentType::kR, FormatMode::kSFloat, 10);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSFloat, 16);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSFloat, 11);
@@ -344,6 +354,7 @@ TEST_F(VertexBufferTest, R11G16B10_SFLOAT) {
   values[2].SetDoubleValue(0.1171875);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32_SFLOAT);  // big enough to cover.
   format->AddComponent(FormatComponentType::kR, FormatMode::kSFloat, 11);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSFloat, 16);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSFloat, 10);
@@ -360,6 +371,7 @@ TEST_F(VertexBufferTest, R32G32B32_SFLOAT) {
   values[2].SetDoubleValue(0.1171875);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR32G32B32_SFLOAT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSFloat, 32);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSFloat, 32);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSFloat, 32);
@@ -378,6 +390,7 @@ TEST_F(VertexBufferTest, R64G64B64_SFLOAT) {
   values[2].SetDoubleValue(0.1171875);
 
   auto format = MakeUnique<Format>();
+  format->SetFormatType(FormatType::kR64G64B64_SFLOAT);
   format->AddComponent(FormatComponentType::kR, FormatMode::kSFloat, 64);
   format->AddComponent(FormatComponentType::kG, FormatMode::kSFloat, 64);
   format->AddComponent(FormatComponentType::kB, FormatMode::kSFloat, 64);