graphics: migrate Vulkan backend to Vulkan-Hpp

src/graphics/host_gpu/renderer/imageView.cpp

@@ -12,13 +12,13 @@ namespace Libs::Graphics {
 namespace {
 
 void CreateRenderTargetView(GraphicContext* ctx, VulkanImage* image, int index,
-                            VkComponentSwizzle r, VkComponentSwizzle g, VkComponentSwizzle b,
-                            VkComponentSwizzle a, VkImageViewType type = VK_IMAGE_VIEW_TYPE_2D,
-                            VkFormat          view_format = VK_FORMAT_UNDEFINED,
-                            VkImageUsageFlags view_usage = 0, uint32_t level_count = 0) {
-	const auto layer_count = type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ? image->layers : 1u;
-	UtilCreateImageView(ctx, image, index, type, VK_IMAGE_ASPECT_COLOR_BIT, {r, g, b, a}, 0, 0,
-	                    layer_count, level_count == 0 ? image->mip_levels : level_count,
+                            vk::ComponentSwizzle r, vk::ComponentSwizzle g, vk::ComponentSwizzle b,
+                            vk::ComponentSwizzle a, vk::ImageViewType type = vk::ImageViewType::e2D,
+                            vk::Format          view_format = vk::Format::eUndefined,
+                            vk::ImageUsageFlags view_usage = {}, uint32_t level_count = 0) {
+	const auto layer_count = type == vk::ImageViewType::e2DArray ? image->layers : 1u;
+	UtilCreateImageView(ctx, image, index, type, vk::ImageAspectFlagBits::eColor, {r, g, b, a}, 0,
+	                    0, layer_count, level_count == 0 ? image->mip_levels : level_count,
 	                    view_format, view_usage);
 }
 
@@ -26,61 +26,67 @@ void CreateRenderTargetView(GraphicContext* ctx, VulkanImage* image, int index,
 
 namespace ImageViewOps {
 
-VkImageAspectFlags DepthAspectMask(VkFormat format) noexcept {
-	return VK_IMAGE_ASPECT_DEPTH_BIT |
-	       (format == VK_FORMAT_D16_UNORM_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT ||
-	                format == VK_FORMAT_D32_SFLOAT_S8_UINT
-	            ? VK_IMAGE_ASPECT_STENCIL_BIT
-	            : 0u);
+vk::ImageAspectFlags DepthAspectMask(vk::Format format) noexcept {
+	auto aspects = vk::ImageAspectFlags {vk::ImageAspectFlagBits::eDepth};
+	if (format == vk::Format::eD16UnormS8Uint || format == vk::Format::eD24UnormS8Uint ||
+	    format == vk::Format::eD32SfloatS8Uint) {
+		aspects |= vk::ImageAspectFlagBits::eStencil;
+	}
+	return aspects;
 }
 
-bool FormatSupportsStorage(GraphicContext* ctx, VkFormat format) {
+bool FormatSupportsStorage(GraphicContext* ctx, vk::Format format) {
 	const auto properties = ctx->GetFormatProperties(format);
-	return (properties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
+	return static_cast<bool>(properties.optimalTilingFeatures &
+	                         vk::FormatFeatureFlagBits::eStorageImage);
 }
 
 void CreateRenderTargetViews(GraphicContext* ctx, RenderTextureVulkanImage* image) {
-	CreateRenderTargetView(ctx, image, VulkanImage::VIEW_DEFAULT, VK_COMPONENT_SWIZZLE_IDENTITY,
-	                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-	                       VK_COMPONENT_SWIZZLE_IDENTITY);
+	CreateRenderTargetView(ctx, image, VulkanImage::VIEW_DEFAULT, vk::ComponentSwizzle::eIdentity,
+	                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+	                       vk::ComponentSwizzle::eIdentity);
 	if (image->layers > 1) {
 		CreateRenderTargetView(ctx, image, VulkanImage::VIEW_DEFAULT_ARRAY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_IMAGE_VIEW_TYPE_2D_ARRAY);
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ImageViewType::e2DArray);
 	}
 	if (FormatSupportsStorage(ctx, image->format)) {
-		CreateRenderTargetView(ctx, image, VulkanImage::VIEW_STORAGE, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_IMAGE_VIEW_TYPE_2D,
-		                       VK_FORMAT_UNDEFINED, 0, 1);
+		CreateRenderTargetView(ctx, image, VulkanImage::VIEW_STORAGE,
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ImageViewType::e2D, vk::Format::eUndefined,
+		                       vk::ImageUsageFlags {}, 1);
 		if (image->layers > 1) {
 			CreateRenderTargetView(ctx, image, VulkanImage::VIEW_STORAGE_ARRAY,
-			                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-			                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-			                       VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_FORMAT_UNDEFINED, 0, 1);
+			                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+			                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+			                       vk::ImageViewType::e2DArray, vk::Format::eUndefined,
+			                       vk::ImageUsageFlags {}, 1);
 		}
 	}
 }
 
 void CreateDepthViews(GraphicContext* ctx, DepthStencilVulkanImage* image) {
-	UtilCreateImageView(ctx, image, VulkanImage::VIEW_DEFAULT, VK_IMAGE_VIEW_TYPE_2D,
+	UtilCreateImageView(ctx, image, VulkanImage::VIEW_DEFAULT, vk::ImageViewType::e2D,
 	                    DepthAspectMask(image->format),
-	                    {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-	                     VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY},
+	                    {vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+	                     vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity},
 	                    0, 0, 1, 1);
 }
 
 void CreateVideoOutViews(GraphicContext* ctx, VideoOutVulkanImage* image) {
-	CreateRenderTargetView(ctx, image, VulkanImage::VIEW_DEFAULT, VK_COMPONENT_SWIZZLE_IDENTITY,
-	                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-	                       VK_COMPONENT_SWIZZLE_IDENTITY);
-	if ((image->format == VK_FORMAT_R8G8B8A8_SRGB || image->format == VK_FORMAT_B8G8R8A8_SRGB) &&
-	    FormatSupportsStorage(ctx, VK_FORMAT_R8G8B8A8_UINT)) {
-		CreateRenderTargetView(ctx, image, VulkanImage::VIEW_STORAGE, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-		                       VK_COMPONENT_SWIZZLE_IDENTITY, VK_IMAGE_VIEW_TYPE_2D,
-		                       VK_FORMAT_R8G8B8A8_UINT, VK_IMAGE_USAGE_STORAGE_BIT, 1);
+	CreateRenderTargetView(ctx, image, VulkanImage::VIEW_DEFAULT, vk::ComponentSwizzle::eIdentity,
+	                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+	                       vk::ComponentSwizzle::eIdentity);
+	if ((image->format == vk::Format::eR8G8B8A8Srgb ||
+	     image->format == vk::Format::eB8G8R8A8Srgb) &&
+	    FormatSupportsStorage(ctx, vk::Format::eR8G8B8A8Uint)) {
+		CreateRenderTargetView(ctx, image, VulkanImage::VIEW_STORAGE,
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ComponentSwizzle::eIdentity, vk::ComponentSwizzle::eIdentity,
+		                       vk::ImageViewType::e2D, vk::Format::eR8G8B8A8Uint,
+		                       vk::ImageUsageFlagBits::eStorage, 1);
 	}
 }
 
@@ -90,14 +96,14 @@ void DestroyViews(GraphicContext* ctx, VulkanImage* image) {
 
 	for (auto& cached: image->view_cache.views) {
 		if (cached.view != nullptr) {
-			vkDestroyImageView(ctx->device, cached.view, nullptr);
+			ctx->device.destroyImageView(cached.view, nullptr);
 			cached.view = nullptr;
 		}
 	}
 	image->view_cache.views.clear();
 	for (auto& view: image->image_view) {
 		if (view != nullptr) {
-			vkDestroyImageView(ctx->device, view, nullptr);
+			ctx->device.destroyImageView(view, nullptr);
 			view = nullptr;
 		}
 	}
@@ -105,12 +111,13 @@ void DestroyViews(GraphicContext* ctx, VulkanImage* image) {
 
 } // namespace ImageViewOps
 
-VkImageView TextureCache::GetRenderTargetAttachmentView(GraphicContext*           ctx,
-                                                        RenderTextureVulkanImage* image,
-                                                        VkFormat format, uint32_t level,
-                                                        uint32_t base_layer, uint32_t layer_count) {
+vk::ImageView TextureCache::GetRenderTargetAttachmentView(GraphicContext*           ctx,
+                                                          RenderTextureVulkanImage* image,
+                                                          vk::Format format, uint32_t level,
+                                                          uint32_t base_layer,
+                                                          uint32_t layer_count) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
-	    format == VK_FORMAT_UNDEFINED || level >= image->mip_levels || level >= 16 ||
+	    format == vk::Format::eUndefined || level >= image->mip_levels || level >= 16 ||
 	    layer_count == 0 || base_layer >= image->layers ||
 	    layer_count > image->layers - base_layer) {
 		EXIT("TextureCache: invalid render-target attachment view, image=%p format=%d"
@@ -127,14 +134,15 @@ VkImageView TextureCache::GetRenderTargetAttachmentView(GraphicContext*
 
 	return GetImageView(ctx, image,
 	                    {format,
-	                     layer_count == 1 ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY,
-	                     VK_IMAGE_ASPECT_COLOR_BIT, level, 1, base_layer, layer_count,
-	                     DstSel(4, 5, 6, 7), VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT});
+	                     layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray,
+	                     vk::ImageAspectFlagBits::eColor, level, 1, base_layer, layer_count,
+	                     DstSel(4, 5, 6, 7), vk::ImageUsageFlagBits::eColorAttachment});
 }
 
-VkImageView TextureCache::GetDepthTargetAttachmentView(GraphicContext*          ctx,
-                                                       DepthStencilVulkanImage* image,
-                                                       uint32_t base_layer, uint32_t layer_count) {
+vk::ImageView TextureCache::GetDepthTargetAttachmentView(GraphicContext*          ctx,
+                                                         DepthStencilVulkanImage* image,
+                                                         uint32_t                 base_layer,
+                                                         uint32_t                 layer_count) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr || layer_count == 0 ||
 	    base_layer >= image->layers || layer_count > image->layers - base_layer) {
 		EXIT("TextureCache: invalid depth-target attachment view, image=%p base_layer=%u "
@@ -144,26 +152,26 @@ VkImageView TextureCache::GetDepthTargetAttachmentView(GraphicContext*
 	}
 	return GetImageView(
 	    ctx, image,
-	    {image->format, layer_count == 1 ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY,
+	    {image->format, layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray,
 	     ImageViewOps::DepthAspectMask(image->format), 0, 1, base_layer, layer_count,
-	     DstSel(4, 5, 6, 7), VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT});
+	     DstSel(4, 5, 6, 7), vk::ImageUsageFlagBits::eDepthStencilAttachment});
 }
 
-VkImageView TextureCache::GetImageView(GraphicContext* ctx, VulkanImage* image,
-                                       const ImageViewInfo& info) {
-	const bool supported_type  = info.type == VK_IMAGE_VIEW_TYPE_2D ||
-	                             info.type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
-	                             info.type == VK_IMAGE_VIEW_TYPE_3D;
-	const bool supported_usage = info.usage == VK_IMAGE_USAGE_SAMPLED_BIT ||
-	                             info.usage == VK_IMAGE_USAGE_STORAGE_BIT ||
-	                             info.usage == VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ||
-	                             info.usage == VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+vk::ImageView TextureCache::GetImageView(GraphicContext* ctx, VulkanImage* image,
+                                         const ImageViewInfo& info) {
+	const bool supported_type  = info.type == vk::ImageViewType::e2D ||
+	                             info.type == vk::ImageViewType::e2DArray ||
+	                             info.type == vk::ImageViewType::e3D;
+	const bool supported_usage = info.usage == vk::ImageUsageFlagBits::eSampled ||
+	                             info.usage == vk::ImageUsageFlagBits::eStorage ||
+	                             info.usage == vk::ImageUsageFlagBits::eColorAttachment ||
+	                             info.usage == vk::ImageUsageFlagBits::eDepthStencilAttachment;
 	const bool valid_shape =
-	    (info.type == VK_IMAGE_VIEW_TYPE_2D && info.layer_count == 1) ||
-	    info.type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
-	    (info.type == VK_IMAGE_VIEW_TYPE_3D && info.base_layer == 0 && info.layer_count == 1);
+	    (info.type == vk::ImageViewType::e2D && info.layer_count == 1) ||
+	    info.type == vk::ImageViewType::e2DArray ||
+	    (info.type == vk::ImageViewType::e3D && info.base_layer == 0 && info.layer_count == 1);
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
-	    info.format == VK_FORMAT_UNDEFINED || info.aspect == 0 || info.level_count == 0 ||
+	    info.format == vk::Format::eUndefined || !info.aspect || info.level_count == 0 ||
 	    info.base_level >= (image != nullptr ? image->mip_levels : 0) ||
 	    info.level_count > image->mip_levels - info.base_level || info.layer_count == 0 ||
 	    info.base_layer >= image->layers || info.layer_count > image->layers - info.base_layer ||
@@ -171,10 +179,11 @@ VkImageView TextureCache::GetImageView(GraphicContext* ctx, VulkanImage* image,
 		EXIT("TextureCache: invalid dynamic image view, image=%p format=%d aspect=0x%x"
 		     " swizzle=0x%03x mip=%u+%u layer=%u+%u type=%d usage=0x%x"
 		     " image_levels=%u image_layers=%u\n",
-		     static_cast<const void*>(image), static_cast<int>(info.format), info.aspect,
-		     info.swizzle, info.base_level, info.level_count, info.base_layer, info.layer_count,
-		     static_cast<int>(info.type), info.usage, image != nullptr ? image->mip_levels : 0,
-		     image != nullptr ? image->layers : 0);
+		     static_cast<const void*>(image), static_cast<int>(info.format),
+		     static_cast<vk::ImageAspectFlags::MaskType>(info.aspect), info.swizzle,
+		     info.base_level, info.level_count, info.base_layer, info.layer_count,
+		     static_cast<int>(info.type), static_cast<vk::ImageUsageFlags::MaskType>(info.usage),
+		     image != nullptr ? image->mip_levels : 0, image != nullptr ? image->layers : 0);
 	}
 
 	auto&           cache = image->view_cache;
@@ -185,67 +194,69 @@ VkImageView TextureCache::GetImageView(GraphicContext* ctx, VulkanImage* image,
 		}
 	}
 
-	VkImageViewUsageCreateInfo usage {};
-	usage.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
+	vk::ImageViewUsageCreateInfo usage {};
+	usage.sType = vk::StructureType::eImageViewUsageCreateInfo;
 	usage.usage = info.usage;
-	VkImageViewCreateInfo create {};
-	create.sType                           = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	vk::ImageViewCreateInfo create {};
+	create.sType                           = vk::StructureType::eImageViewCreateInfo;
 	create.pNext                           = &usage;
 	create.image                           = image->image;
 	create.viewType                        = info.type;
 	create.format                          = info.format;
-	create.components                      = info.usage == VK_IMAGE_USAGE_SAMPLED_BIT
+	create.components                      = info.usage == vk::ImageUsageFlagBits::eSampled
 	                                             ? TextureGetComponentMapping(info.swizzle)
-	                                             : VkComponentMapping {};
+	                                             : vk::ComponentMapping {};
 	create.subresourceRange.aspectMask     = info.aspect;
 	create.subresourceRange.baseMipLevel   = info.base_level;
 	create.subresourceRange.levelCount     = info.level_count;
 	create.subresourceRange.baseArrayLayer = info.base_layer;
 	create.subresourceRange.layerCount     = info.layer_count;
-	VkImageView view                       = nullptr;
-	const auto  result = vkCreateImageView(ctx->device, &create, nullptr, &view);
-	if (result != VK_SUCCESS || view == nullptr) {
+	vk::ImageView view                     = nullptr;
+	const auto    result                   = ctx->device.createImageView(&create, nullptr, &view);
+	if (result != vk::Result::eSuccess || view == nullptr) {
 		EXIT("TextureCache: failed to create dynamic image view, result=%d format=%d"
 		     " aspect=0x%x swizzle=0x%03x mip=%u+%u layer=%u+%u type=%d usage=0x%x\n",
-		     static_cast<int>(result), static_cast<int>(info.format), info.aspect, info.swizzle,
+		     static_cast<int>(result), static_cast<int>(info.format),
+		     static_cast<vk::ImageAspectFlags::MaskType>(info.aspect), info.swizzle,
 		     info.base_level, info.level_count, info.base_layer, info.layer_count,
-		     static_cast<int>(info.type), info.usage);
+		     static_cast<int>(info.type), static_cast<vk::ImageUsageFlags::MaskType>(info.usage));
 	}
 	cache.views.push_back({info, view});
 	return view;
 }
 
-VkImageView TextureCache::GetDepthTargetSampledView(GraphicContext*          ctx,
-                                                    DepthStencilVulkanImage* image,
-                                                    VkFormat view_format, uint32_t swizzle,
-                                                    uint32_t base_level, uint32_t level_count,
-                                                    VkImageViewType type, uint32_t base_layer,
-                                                    uint32_t layer_count) {
+vk::ImageView TextureCache::GetDepthTargetSampledView(GraphicContext*          ctx,
+                                                      DepthStencilVulkanImage* image,
+                                                      vk::Format view_format, uint32_t swizzle,
+                                                      uint32_t base_level, uint32_t level_count,
+                                                      vk::ImageViewType type, uint32_t base_layer,
+                                                      uint32_t layer_count) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
-	    view_format == VK_FORMAT_UNDEFINED ||
+	    view_format == vk::Format::eUndefined ||
 	    !IsSupportedSampledDepthView(image->format, view_format, swizzle)) {
 		EXIT("TextureCache: invalid sampled depth-target view, image=%p image_format=%d"
 		     " view_format=%d swizzle=0x%03x mip=%u+%u layer=%u+%u type=%d"
 		     " image_levels=%u image_layers=%u\n",
 		     static_cast<const void*>(image),
-		     image != nullptr ? static_cast<int>(image->format) : VK_FORMAT_UNDEFINED,
+		     image != nullptr ? static_cast<int>(image->format)
+		                      : static_cast<int>(vk::Format::eUndefined),
 		     static_cast<int>(view_format), swizzle, base_level, level_count, base_layer,
 		     layer_count, static_cast<int>(type), image != nullptr ? image->mip_levels : 0,
 		     image != nullptr ? image->layers : 0);
 	}
 	return GetImageView(ctx, image,
-	                    {image->format, type, VK_IMAGE_ASPECT_DEPTH_BIT, base_level, level_count,
-	                     base_layer, layer_count, swizzle});
+	                    {image->format, type, vk::ImageAspectFlagBits::eDepth, base_level,
+	                     level_count, base_layer, layer_count, swizzle});
 }
 
-VkImageView TextureCache::GetSampledColorView(GraphicContext* ctx, VulkanImage* image,
-                                              VkFormat view_format, uint32_t swizzle,
-                                              uint32_t base_level, uint32_t level_count,
-                                              VkImageViewType type, uint32_t base_layer,
-                                              uint32_t layer_count) {
+vk::ImageView TextureCache::GetSampledColorView(GraphicContext* ctx, VulkanImage* image,
+                                                vk::Format view_format, uint32_t swizzle,
+                                                uint32_t base_level, uint32_t level_count,
+                                                vk::ImageViewType type, uint32_t base_layer,
+                                                uint32_t layer_count) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
-	    view_format == VK_FORMAT_UNDEFINED || base_level >= 16 ||
-	    (type != VK_IMAGE_VIEW_TYPE_2D && type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) ||
+	    view_format == vk::Format::eUndefined || base_level >= 16 ||
+	    (type != vk::ImageViewType::e2D && type != vk::ImageViewType::e2DArray) ||
 	    !IsSupportedSampledColorView(image->format, view_format, swizzle)) {
 		EXIT("TextureCache: invalid sampled color view, image=%p swizzle=0x%03x"
 		     " view_format=%d mip=%u+%u layer=%u+%u type=%d image_levels=%u image_layers=%u\n",
@@ -253,29 +264,29 @@ VkImageView TextureCache::GetSampledColorView(GraphicContext* ctx, VulkanImage*
 		     level_count, base_layer, layer_count, static_cast<int>(type),
 		     image != nullptr ? image->mip_levels : 0, image != nullptr ? image->layers : 0);
 	}
-	const auto precreated_view = type == VK_IMAGE_VIEW_TYPE_2D_ARRAY
+	const auto precreated_view = type == vk::ImageViewType::e2DArray
 	                                 ? VulkanImage::VIEW_DEFAULT_ARRAY
 	                                 : VulkanImage::VIEW_DEFAULT;
 	const bool full_view =
 	    base_level == 0 && level_count == image->mip_levels && base_layer == 0 &&
-	    layer_count == (type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ? image->layers : 1u);
+	    layer_count == (type == vk::ImageViewType::e2DArray ? image->layers : 1u);
 	if (view_format == image->format && swizzle == DstSel(4, 5, 6, 7) && full_view &&
 	    image->image_view[precreated_view] != nullptr) {
 		return image->image_view[precreated_view];
 	}
 	return GetImageView(ctx, image,
-	                    {view_format, type, VK_IMAGE_ASPECT_COLOR_BIT, base_level, level_count,
-	                     base_layer, layer_count, swizzle});
+	                    {view_format, type, vk::ImageAspectFlagBits::eColor, base_level,
+	                     level_count, base_layer, layer_count, swizzle});
 }
 
-VkImageView TextureCache::GetRenderTargetStorageView(GraphicContext*           ctx,
-                                                     RenderTextureVulkanImage* image,
-                                                     VkFormat view_format, uint32_t base_level,
-                                                     uint32_t level_count, VkImageViewType type,
-                                                     uint32_t base_layer, uint32_t layer_count) {
+vk::ImageView TextureCache::GetRenderTargetStorageView(GraphicContext*           ctx,
+                                                       RenderTextureVulkanImage* image,
+                                                       vk::Format view_format, uint32_t base_level,
+                                                       uint32_t level_count, vk::ImageViewType type,
+                                                       uint32_t base_layer, uint32_t layer_count) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
-	    view_format == VK_FORMAT_UNDEFINED ||
-	    (type != VK_IMAGE_VIEW_TYPE_2D && type != VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
+	    view_format == vk::Format::eUndefined ||
+	    (type != vk::ImageViewType::e2D && type != vk::ImageViewType::e2DArray)) {
 		EXIT("TextureCache: invalid render-target storage view, image=%p view_format=%d"
 		     " mip=%u+%u layer=%u+%u type=%d image_levels=%u image_layers=%u\n",
 		     static_cast<const void*>(image), static_cast<int>(view_format), base_level,
@@ -291,11 +302,11 @@ VkImageView TextureCache::GetRenderTargetStorageView(GraphicContext*           c
 		     level_count);
 	}
 	if (exact) {
-		const auto index = type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ? VulkanImage::VIEW_STORAGE_ARRAY
+		const auto index = type == vk::ImageViewType::e2DArray ? VulkanImage::VIEW_STORAGE_ARRAY
 		                                                       : VulkanImage::VIEW_STORAGE;
 		const bool full_view =
 		    base_level == 0 && level_count == 1 && base_layer == 0 &&
-		    layer_count == (type == VK_IMAGE_VIEW_TYPE_2D_ARRAY ? image->layers : 1u);
+		    layer_count == (type == vk::ImageViewType::e2DArray ? image->layers : 1u);
 		if (full_view && image->image_view[index] != nullptr) {
 			return image->image_view[index];
 		}
@@ -308,13 +319,14 @@ VkImageView TextureCache::GetRenderTargetStorageView(GraphicContext*           c
 		     level_count);
 	}
 	return GetImageView(ctx, image,
-	                    {view_format, type, VK_IMAGE_ASPECT_COLOR_BIT, base_level, level_count,
-	                     base_layer, layer_count, DstSel(4, 5, 6, 7), VK_IMAGE_USAGE_STORAGE_BIT});
+	                    {view_format, type, vk::ImageAspectFlagBits::eColor, base_level,
+	                     level_count, base_layer, layer_count, DstSel(4, 5, 6, 7),
+	                     vk::ImageUsageFlagBits::eStorage});
 }
 
-VkImageView TextureCache::GetStorageTextureSampledView(GraphicContext*            ctx,
-                                                       StorageTextureVulkanImage* image,
-                                                       const ImageInfo&           info) {
+vk::ImageView TextureCache::GetStorageTextureSampledView(GraphicContext*            ctx,
+                                                         StorageTextureVulkanImage* image,
+                                                         const ImageInfo&           info) {
 	const auto shape =
 	    SelectStorageSampledViewShape(info.type, info.depth, image != nullptr ? image->layers : 0);
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
@@ -334,23 +346,23 @@ VkImageView TextureCache::GetStorageTextureSampledView(GraphicContext*
 		     static_cast<int>(image->format), static_cast<int>(view_format), info.swizzle);
 	}
 
-	VkImageViewType type = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
+	vk::ImageViewType type = static_cast<vk::ImageViewType>(VK_IMAGE_VIEW_TYPE_MAX_ENUM);
 	switch (shape) {
-		case StorageSampledViewShape::Image2D: type = VK_IMAGE_VIEW_TYPE_2D; break;
-		case StorageSampledViewShape::Image2DArray: type = VK_IMAGE_VIEW_TYPE_2D_ARRAY; break;
-		case StorageSampledViewShape::Image3D: type = VK_IMAGE_VIEW_TYPE_3D; break;
+		case StorageSampledViewShape::Image2D: type = vk::ImageViewType::e2D; break;
+		case StorageSampledViewShape::Image2DArray: type = vk::ImageViewType::e2DArray; break;
+		case StorageSampledViewShape::Image3D: type = vk::ImageViewType::e3D; break;
 		case StorageSampledViewShape::Unsupported:
 			EXIT("TextureCache: unsupported sampled storage-image view shape\n");
 	}
 	const auto layer_count = shape == StorageSampledViewShape::Image2DArray ? info.depth : 1u;
 	return GetImageView(ctx, image,
-	                    {view_format, type, VK_IMAGE_ASPECT_COLOR_BIT, info.base_level,
+	                    {view_format, type, vk::ImageAspectFlagBits::eColor, info.base_level,
 	                     info.view_levels, 0, layer_count, info.swizzle});
 }
 
-VkImageView TextureCache::GetStorageTextureStorageView(GraphicContext*            ctx,
-                                                       StorageTextureVulkanImage* image,
-                                                       uint32_t                   base_level) {
+vk::ImageView TextureCache::GetStorageTextureStorageView(GraphicContext*            ctx,
+                                                         StorageTextureVulkanImage* image,
+                                                         uint32_t                   base_level) {
 	if (ctx == nullptr || image == nullptr || image->image == nullptr ||
 	    base_level >= (image != nullptr ? image->mip_levels : 0)) {
 		EXIT("TextureCache: invalid storage-texture mip view, image=%p level=%u levels=%u\n",
@@ -360,8 +372,9 @@ VkImageView TextureCache::GetStorageTextureStorageView(GraphicContext*
 		return image->image_view[VulkanImage::VIEW_DEFAULT];
 	}
 	return GetImageView(ctx, image,
-	                    {image->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT,
-	                     base_level, 1, 0, 1, DstSel(4, 5, 6, 7), VK_IMAGE_USAGE_STORAGE_BIT});
+	                    {image->format, vk::ImageViewType::e2D, vk::ImageAspectFlagBits::eColor,
+	                     base_level, 1, 0, 1, DstSel(4, 5, 6, 7),
+	                     vk::ImageUsageFlagBits::eStorage});
 }
 
 } // namespace Libs::Graphics