// 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/device.h" #include #include // Vulkan wrappers: std::setw(), std::left/right #include #include #include #include #include #include #include "src/make_unique.h" namespace amber { namespace vulkan { namespace { const char kVariablePointers[] = "VariablePointerFeatures.variablePointers"; const char kVariablePointersStorageBuffer[] = "VariablePointerFeatures.variablePointersStorageBuffer"; struct BaseOutStructure { VkStructureType sType; void* pNext; }; bool AreAllRequiredFeaturesSupported( const VkPhysicalDeviceFeatures& available_features, const std::vector& required_features) { if (required_features.empty()) return true; for (const auto& feature : required_features) { if (feature == "robustBufferAccess") { if (available_features.robustBufferAccess == VK_FALSE) return false; continue; } if (feature == "fullDrawIndexUint32") { if (available_features.fullDrawIndexUint32 == VK_FALSE) return false; continue; } if (feature == "imageCubeArray") { if (available_features.imageCubeArray == VK_FALSE) return false; continue; } if (feature == "independentBlend") { if (available_features.independentBlend == VK_FALSE) return false; continue; } if (feature == "geometryShader") { if (available_features.geometryShader == VK_FALSE) return false; continue; } if (feature == "tessellationShader") { if (available_features.tessellationShader == VK_FALSE) return false; continue; } if (feature == "sampleRateShading") { if (available_features.sampleRateShading == VK_FALSE) return false; continue; } if (feature == "dualSrcBlend") { if (available_features.dualSrcBlend == VK_FALSE) return false; continue; } if (feature == "logicOp") { if (available_features.logicOp == VK_FALSE) return false; continue; } if (feature == "multiDrawIndirect") { if (available_features.multiDrawIndirect == VK_FALSE) return false; continue; } if (feature == "drawIndirectFirstInstance") { if (available_features.drawIndirectFirstInstance == VK_FALSE) return false; continue; } if (feature == "depthClamp") { if (available_features.depthClamp == VK_FALSE) return false; continue; } if (feature == "depthBiasClamp") { if (available_features.depthBiasClamp == VK_FALSE) return false; continue; } if (feature == "fillModeNonSolid") { if (available_features.fillModeNonSolid == VK_FALSE) return false; continue; } if (feature == "depthBounds") { if (available_features.depthBounds == VK_FALSE) return false; continue; } if (feature == "wideLines") { if (available_features.wideLines == VK_FALSE) return false; continue; } if (feature == "largePoints") { if (available_features.largePoints == VK_FALSE) return false; continue; } if (feature == "alphaToOne") { if (available_features.alphaToOne == VK_FALSE) return false; continue; } if (feature == "multiViewport") { if (available_features.multiViewport == VK_FALSE) return false; continue; } if (feature == "samplerAnisotropy") { if (available_features.samplerAnisotropy == VK_FALSE) return false; continue; } if (feature == "textureCompressionETC2") { if (available_features.textureCompressionETC2 == VK_FALSE) return false; continue; } if (feature == "textureCompressionASTC_LDR") { if (available_features.textureCompressionASTC_LDR == VK_FALSE) return false; continue; } if (feature == "textureCompressionBC") { if (available_features.textureCompressionBC == VK_FALSE) return false; continue; } if (feature == "occlusionQueryPrecise") { if (available_features.occlusionQueryPrecise == VK_FALSE) return false; continue; } if (feature == "pipelineStatisticsQuery") { if (available_features.pipelineStatisticsQuery == VK_FALSE) return false; continue; } if (feature == "vertexPipelineStoresAndAtomics") { if (available_features.vertexPipelineStoresAndAtomics == VK_FALSE) return false; continue; } if (feature == "fragmentStoresAndAtomics") { if (available_features.fragmentStoresAndAtomics == VK_FALSE) return false; continue; } if (feature == "shaderTessellationAndGeometryPointSize") { if (available_features.shaderTessellationAndGeometryPointSize == VK_FALSE) return false; continue; } if (feature == "shaderImageGatherExtended") { if (available_features.shaderImageGatherExtended == VK_FALSE) return false; continue; } if (feature == "shaderStorageImageExtendedFormats") { if (available_features.shaderStorageImageExtendedFormats == VK_FALSE) return false; continue; } if (feature == "shaderStorageImageMultisample") { if (available_features.shaderStorageImageMultisample == VK_FALSE) return false; continue; } if (feature == "shaderStorageImageReadWithoutFormat") { if (available_features.shaderStorageImageReadWithoutFormat == VK_FALSE) return false; continue; } if (feature == "shaderStorageImageWriteWithoutFormat") { if (available_features.shaderStorageImageWriteWithoutFormat == VK_FALSE) return false; continue; } if (feature == "shaderUniformBufferArrayDynamicIndexing") { if (available_features.shaderUniformBufferArrayDynamicIndexing == VK_FALSE) return false; continue; } if (feature == "shaderSampledImageArrayDynamicIndexing") { if (available_features.shaderSampledImageArrayDynamicIndexing == VK_FALSE) return false; continue; } if (feature == "shaderStorageBufferArrayDynamicIndexing") { if (available_features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE) return false; continue; } if (feature == "shaderStorageImageArrayDynamicIndexing") { if (available_features.shaderStorageImageArrayDynamicIndexing == VK_FALSE) return false; continue; } if (feature == "shaderClipDistance") { if (available_features.shaderClipDistance == VK_FALSE) return false; continue; } if (feature == "shaderCullDistance") { if (available_features.shaderCullDistance == VK_FALSE) return false; continue; } if (feature == "shaderFloat64") { if (available_features.shaderFloat64 == VK_FALSE) return false; continue; } if (feature == "shaderInt64") { if (available_features.shaderInt64 == VK_FALSE) return false; continue; } if (feature == "shaderInt16") { if (available_features.shaderInt16 == VK_FALSE) return false; continue; } if (feature == "shaderResourceResidency") { if (available_features.shaderResourceResidency == VK_FALSE) return false; continue; } if (feature == "shaderResourceMinLod") { if (available_features.shaderResourceMinLod == VK_FALSE) return false; continue; } if (feature == "sparseBinding") { if (available_features.sparseBinding == VK_FALSE) return false; continue; } if (feature == "sparseResidencyBuffer") { if (available_features.sparseResidencyBuffer == VK_FALSE) return false; continue; } if (feature == "sparseResidencyImage2D") { if (available_features.sparseResidencyImage2D == VK_FALSE) return false; continue; } if (feature == "sparseResidencyImage3D") { if (available_features.sparseResidencyImage3D == VK_FALSE) return false; continue; } if (feature == "sparseResidency2Samples") { if (available_features.sparseResidency2Samples == VK_FALSE) return false; continue; } if (feature == "sparseResidency4Samples") { if (available_features.sparseResidency4Samples == VK_FALSE) return false; continue; } if (feature == "sparseResidency8Samples") { if (available_features.sparseResidency8Samples == VK_FALSE) return false; continue; } if (feature == "sparseResidency16Samples") { if (available_features.sparseResidency16Samples == VK_FALSE) return false; continue; } if (feature == "sparseResidencyAliased") { if (available_features.sparseResidencyAliased == VK_FALSE) return false; continue; } if (feature == "variableMultisampleRate") { if (available_features.variableMultisampleRate == VK_FALSE) return false; continue; } if (feature == "inheritedQueries") { if (available_features.inheritedQueries == VK_FALSE) return false; continue; } } return true; } bool AreAllExtensionsSupported( const std::vector& available_extensions, const std::vector& required_extensions) { if (required_extensions.empty()) return true; std::set required_extension_set(required_extensions.begin(), required_extensions.end()); for (const auto& extension : available_extensions) { required_extension_set.erase(extension); } return required_extension_set.empty(); } } // namespace Device::Device(VkInstance instance, VkPhysicalDevice physical_device, uint32_t queue_family_index, VkDevice device, VkQueue queue) : instance_(instance), physical_device_(physical_device), device_(device), queue_(queue), queue_family_index_(queue_family_index) {} Device::~Device() = default; Result Device::LoadVulkanPointers(PFN_vkGetInstanceProcAddr getInstanceProcAddr, Delegate* delegate) { // Note: logging Vulkan calls is done via the delegate rather than a Vulkan // layer because we want such logging even when Amber is built as a native // executable on Android, where Vulkan layers are usable only with APKs. if (delegate && delegate->LogGraphicsCalls()) delegate->Log("Loading Vulkan Pointers"); #include "vk-wrappers.inc" return {}; } Result Device::Initialize( PFN_vkGetInstanceProcAddr getInstanceProcAddr, Delegate* delegate, const std::vector& required_features, const std::vector& required_extensions, const VkPhysicalDeviceFeatures& available_features, const VkPhysicalDeviceFeatures2KHR& available_features2, const std::vector& available_extensions) { Result r = LoadVulkanPointers(getInstanceProcAddr, delegate); if (!r.IsSuccess()) return r; bool use_physical_device_features_2 = false; // Determine if VkPhysicalDeviceProperties2KHR should be used for (auto& ext : required_extensions) { if (ext == "VK_KHR_get_physical_device_properties2") { use_physical_device_features_2 = true; } } VkPhysicalDeviceFeatures available_vulkan_features = VkPhysicalDeviceFeatures(); if (use_physical_device_features_2) { available_vulkan_features = available_features2.features; VkPhysicalDeviceVariablePointerFeaturesKHR* var_ptrs = nullptr; void* ptr = available_features2.pNext; while (ptr != nullptr) { BaseOutStructure* s = static_cast(ptr); if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR) { var_ptrs = static_cast(ptr); break; } ptr = s->pNext; } std::vector required_features1; for (const auto& feature : required_features) { // No dot means this is a features1 feature. if (feature.find_first_of('.') == std::string::npos) { required_features1.push_back(feature); continue; } if ((feature == kVariablePointers || feature == kVariablePointersStorageBuffer) && var_ptrs == nullptr) { return amber::Result( "Variable pointers requested but feature not returned"); } if (feature == kVariablePointers && var_ptrs->variablePointers != VK_TRUE) { return amber::Result("Missing variable pointers feature"); } if (feature == kVariablePointersStorageBuffer && var_ptrs->variablePointersStorageBuffer != VK_TRUE) { return amber::Result( "Missing variable pointers storage buffer feature"); } } } else { available_vulkan_features = available_features; } if (!AreAllRequiredFeaturesSupported(available_vulkan_features, required_features)) { return Result( "Vulkan: Device::Initialize given physical device does not support " "required features"); } if (!AreAllExtensionsSupported(available_extensions, required_extensions)) { return Result( "Vulkan: Device::Initialize given physical device does not support " "required extensions"); } ptrs_.vkGetPhysicalDeviceProperties(physical_device_, &physical_device_properties_); ptrs_.vkGetPhysicalDeviceMemoryProperties(physical_device_, &physical_memory_properties_); return {}; } bool Device::IsFormatSupportedByPhysicalDevice(const Format& format, Buffer* buffer) { VkFormat vk_format = GetVkFormat(format); VkFormatProperties properties = VkFormatProperties(); GetPtrs()->vkGetPhysicalDeviceFormatProperties(physical_device_, vk_format, &properties); VkFormatFeatureFlagBits flag = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; bool is_buffer_type_image = false; switch (buffer->GetBufferType()) { case BufferType::kColor: flag = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; is_buffer_type_image = true; break; case BufferType::kDepth: flag = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; is_buffer_type_image = true; break; case BufferType::kSampled: flag = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; is_buffer_type_image = true; break; case BufferType::kVertex: flag = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; is_buffer_type_image = false; break; default: return false; } return ((is_buffer_type_image ? properties.optimalTilingFeatures : properties.bufferFeatures) & flag) == flag; } bool Device::HasMemoryFlags(uint32_t memory_type_index, const VkMemoryPropertyFlags flags) const { return (physical_memory_properties_.memoryTypes[memory_type_index] .propertyFlags & flags) == flags; } bool Device::IsMemoryHostAccessible(uint32_t memory_type_index) const { return HasMemoryFlags(memory_type_index, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); } bool Device::IsMemoryHostCoherent(uint32_t memory_type_index) const { return HasMemoryFlags(memory_type_index, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); } uint32_t Device::GetMaxPushConstants() const { return physical_device_properties_.limits.maxPushConstantsSize; } bool Device::IsDescriptorSetInBounds(uint32_t descriptor_set) const { VkPhysicalDeviceProperties properties = VkPhysicalDeviceProperties(); GetPtrs()->vkGetPhysicalDeviceProperties(physical_device_, &properties); 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