From e31aadd162ebe87d523631b56400b8a94c72117a Mon Sep 17 00:00:00 2001 From: dan sinclair Date: Wed, 27 Mar 2019 16:46:55 -0400 Subject: [PATCH] [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. --- Android.mk | 1 - src/format.cc | 148 ++++++++ src/format.h | 18 +- src/vulkan/CMakeLists.txt | 1 - src/vulkan/device.cc | 400 ++++++++++++++++++++- src/vulkan/device.h | 1 + src/vulkan/engine_vulkan.cc | 15 +- src/vulkan/format_data.cc | 572 ------------------------------- src/vulkan/format_data.h | 33 -- src/vulkan/frame_buffer.cc | 17 +- src/vulkan/frame_buffer.h | 2 +- src/vulkan/graphics_pipeline.cc | 21 +- src/vulkan/graphics_pipeline.h | 6 +- src/vulkan/index_buffer.cc | 1 - src/vulkan/resource.cc | 1 - src/vulkan/transfer_image.cc | 7 +- src/vulkan/transfer_image.h | 3 +- src/vulkan/vertex_buffer.cc | 4 +- src/vulkan/vertex_buffer_test.cc | 13 + 19 files changed, 601 insertions(+), 663 deletions(-) delete mode 100644 src/vulkan/format_data.cc delete mode 100644 src/vulkan/format_data.h diff --git a/Android.mk b/Android.mk index 7d8ca0f0a..1e5fbadf5 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 08813790a..1429ddf70 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 f617f095f..307340dfd 100644 --- a/src/format.h +++ b/src/format.h @@ -56,19 +56,17 @@ class Format { } const std::vector& 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 components_; }; diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt index 376ea5334..6c6d29938 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 6a513307d..5621ae162 100644 --- a/src/vulkan/device.cc +++ b/src/vulkan/device.cc @@ -24,7 +24,6 @@ #include #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 8f9d9dccb..e55bf8835 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 a94dba7f0..33eb9d547 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 stage_create_info; @@ -181,9 +179,8 @@ Result EngineVulkan::CreatePipeline(amber::Pipeline* pipeline) { return r; } else { vk_pipeline = MakeUnique( - 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 03220dc5b..000000000 --- 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 85ba6ba4d..000000000 --- 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 - -#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 308e622fa..33be51c67 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 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( - 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( device_, depth_format, - static_cast( - VkFormatHasStencilComponent(depth_format) - ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT - : VK_IMAGE_ASPECT_DEPTH_BIT), + static_cast(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 799516323..2f21c7391 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 a9db294a9..b3176bb16 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& color_buffers, - VkFormat depth_stencil_format, + const Format& depth_stencil_format, uint32_t fence_timeout_ms, const std::vector& 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 58d5dca65..fa84948cf 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& color_buffers, - VkFormat depth_stencil_format, + const Format& depth_stencil_format, uint32_t fence_timeout_ms, const std::vector&); ~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 color_buffers_; - VkFormat depth_stencil_format_; + Format depth_stencil_format_; std::unique_ptr index_buffer_; uint32_t frame_width_ = 0; diff --git a/src/vulkan/index_buffer.cc b/src/vulkan/index_buffer.cc index 4293471c2..625a18b0e 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 4d93e35f8..e90e7c19d 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 40d44aaba..60f29a34b 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 df70c008d..a1cac081c 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 5df65c8d4..9aa150bcc 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 26e740c63..a4bb7e7ae 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->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->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->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->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->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->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->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->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->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->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->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->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->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);