lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-24 15:36:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add support for VK_KHR_extended_flags

Browse Source
This commit is contained in:
baldurk
2026-07-27 12:37:28 +01:00
parent 63b38ef8b4
commit c6949d9c45
13 changed files with 1455 additions and 1098 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/extension_support.md
+1 -1
View File
@@ -172,6 +172,7 @@ Maintainers can update this file by updating vk.xml in this folder and running `
* `VK_KHR_driver_properties`
* `VK_KHR_dynamic_rendering_local_read`
* `VK_KHR_dynamic_rendering`
* `VK_KHR_extended_flags`
* `VK_KHR_external_fence_capabilities`
* `VK_KHR_external_fence_fd`
* `VK_KHR_external_fence_win32`
@@ -303,7 +304,6 @@ KHR extensions will definitely be implemented at some point, though KHR extensio
* `VK_KHR_copy_memory_indirect`
* `VK_KHR_device_address_commands`
* `VK_KHR_device_fault`
* `VK_KHR_extended_flags`
* `VK_KHR_internally_synchronized_queues`
* `VK_KHR_maintenance10`
* `VK_KHR_maintenance11`
renderdoc/driver/vulkan/vk_common.h
+110 -3
View File
@@ -76,6 +76,9 @@
#define VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2_VkFlags64_typedef
#define VkBufferUsageFlagBits2 VkBufferUsageFlagBits2_VkFlags64_typedef
#define VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2_VkFlags64_typedef
#define VkFormatFeatureFlagBits4KHR VkFormatFeatureFlagBits4KHR_VkFlags64_typedef
#define VkImageUsageFlagBits2KHR VkImageUsageFlagBits2KHR_VkFlags64_typedef
#define VkImageCreateFlagBits2KHR VkImageUsageFlagBits2KHR_VkFlags64_typedef
#include "core/core.h"
#include "core/resource_manager.h"
@@ -90,6 +93,9 @@
#undef VkFormatFeatureFlagBits2
#undef VkBufferUsageFlagBits2
#undef VkPipelineCreateFlagBits2
#undef VkFormatFeatureFlagBits4KHR
#undef VkImageUsageFlagBits2KHR
#undef VkImageCreateFlagBits2KHR
#undef Bool
#undef None
@@ -141,17 +147,17 @@ VkShaderStageFlags ShaderMaskFromIndex(size_t index);
// Generic getter/setter helpers to handle optional 64 flag structs in the pNext chain
template <typename ParentStruct>
uint64_t GetBufferUsageFlags(const ParentStruct *info)
VkBufferUsageFlags2 GetBufferUsageFlags(const ParentStruct *info)
{
const VkBufferUsageFlags2CreateInfo *usage2 = (const VkBufferUsageFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
if(usage2)
return usage2->usage;
return info->usage;
return (VkBufferUsageFlags2)info->usage;
}
template <typename ParentStruct>
void SetBufferUsageFlags(ParentStruct *info, uint64_t usage)
void SetBufferUsageFlags(ParentStruct *info, VkBufferUsageFlags2 usage)
{
VkBufferUsageFlags2CreateInfo *usage2 = (VkBufferUsageFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
@@ -163,6 +169,78 @@ void SetBufferUsageFlags(ParentStruct *info, uint64_t usage)
info->usage = (VkBufferUsageFlags)usage;
}
template <typename ParentStruct>
VkImageUsageFlags2KHR GetImageUsageFlags(const ParentStruct *info)
{
const VkImageUsageFlags2CreateInfoKHR *usage2 =
(const VkImageUsageFlags2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR);
if(usage2)
return usage2->usage;
return (VkImageUsageFlags2KHR)info->usage;
}
template <typename ParentStruct>
void SetImageUsageFlags(ParentStruct *info, VkImageUsageFlags2KHR usage)
{
VkImageUsageFlags2CreateInfoKHR *usage2 = (VkImageUsageFlags2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR);
if(usage2)
{
usage2->usage = usage;
return;
}
info->usage = (VkImageUsageFlags)usage;
}
template <typename ParentStruct>
VkImageUsageFlags2KHR GetImageViewUsageFlags(const ParentStruct *info)
{
const VkImageViewUsage2CreateInfoKHR *usage2 =
(const VkImageViewUsage2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR);
if(usage2)
return usage2->usage;
return (VkImageUsageFlags2KHR)info->usage;
}
template <typename ParentStruct>
void SetImageViewUsageFlags(ParentStruct *info, VkImageUsageFlags2KHR usage)
{
VkImageViewUsage2CreateInfoKHR *usage2 = (VkImageViewUsage2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR);
if(usage2)
{
usage2->usage = usage;
return;
}
info->usage = (VkImageUsageFlags)usage;
}
template <typename ParentStruct>
VkImageCreateFlags2KHR GetImageCreateFlags(const ParentStruct *info)
{
const VkImageCreateFlags2CreateInfoKHR *create2 =
(const VkImageCreateFlags2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR);
if(create2)
return create2->flags;
return (VkImageCreateFlags2KHR)info->flags;
}
template <typename ParentStruct>
void SetImageCreateFlags(ParentStruct *info, VkImageCreateFlags2KHR flags)
{
VkImageCreateFlags2CreateInfoKHR *create2 = (VkImageCreateFlags2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR);
if(create2)
{
create2->flags = flags;
return;
}
info->flags = (VkImageCreateFlags)flags;
}
template <typename ParentStruct>
uint64_t GetPipelineCreateFlags(const ParentStruct *info)
{
@@ -1604,6 +1682,7 @@ DECLARE_REFLECTION_STRUCT(VkFenceGetFdInfoKHR);
DECLARE_REFLECTION_STRUCT(VkFilterCubicImageViewImageFormatPropertiesEXT);
DECLARE_REFLECTION_STRUCT(VkFormatProperties2);
DECLARE_REFLECTION_STRUCT(VkFormatProperties3);
DECLARE_REFLECTION_STRUCT(VkFormatProperties4KHR);
DECLARE_REFLECTION_STRUCT(VkFragmentShadingRateAttachmentInfoKHR);
DECLARE_REFLECTION_STRUCT(VkFramebufferAttachmentImageInfo);
DECLARE_REFLECTION_STRUCT(VkFramebufferAttachmentsCreateInfo);
@@ -1619,6 +1698,7 @@ DECLARE_REFLECTION_STRUCT(VkImageCompressionControlEXT);
DECLARE_REFLECTION_STRUCT(VkImageCompressionPropertiesEXT);
DECLARE_REFLECTION_STRUCT(VkImageCopy2);
DECLARE_REFLECTION_STRUCT(VkImageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageCreateFlags2CreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImageDrmFormatModifierExplicitCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkImageDrmFormatModifierListCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkImageDrmFormatModifierPropertiesEXT);
@@ -1631,15 +1711,18 @@ DECLARE_REFLECTION_STRUCT(VkImagePlaneMemoryRequirementsInfo);
DECLARE_REFLECTION_STRUCT(VkImageResolve2);
DECLARE_REFLECTION_STRUCT(VkImageSparseMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkImageStencilUsageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageStencilUsage2CreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImageSubresource2);
DECLARE_REFLECTION_STRUCT(VkImageSwapchainCreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImageToMemoryCopy);
DECLARE_REFLECTION_STRUCT(VkImageUsageFlags2CreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImageViewASTCDecodeModeEXT);
DECLARE_REFLECTION_STRUCT(VkImageViewCaptureDescriptorDataInfoEXT);
DECLARE_REFLECTION_STRUCT(VkImageViewCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageViewMinLodCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkImageViewSlicedCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkImageViewUsageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageViewUsage2CreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImportFenceFdInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImportMemoryFdInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImportSemaphoreFdInfoKHR);
@@ -1714,6 +1797,7 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedFlagsFeaturesKHR);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalBufferInfo);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalFenceInfo);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalImageFormatInfo);
@@ -2002,6 +2086,7 @@ DECLARE_REFLECTION_STRUCT(VkShaderCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkShaderModuleCreateInfo);
DECLARE_REFLECTION_STRUCT(VkShaderModuleValidationCacheCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkSharedPresentSurfaceCapabilitiesKHR);
DECLARE_REFLECTION_STRUCT(VkSharedPresentSurfaceCapabilities2KHR);
DECLARE_REFLECTION_STRUCT(VkSparseImageFormatProperties2);
DECLARE_REFLECTION_STRUCT(VkSparseImageMemoryRequirements2);
DECLARE_REFLECTION_STRUCT(VkSubmitInfo);
@@ -2185,6 +2270,7 @@ DECLARE_DESERIALISE_TYPE(VkFenceGetFdInfoKHR);
DECLARE_DESERIALISE_TYPE(VkFilterCubicImageViewImageFormatPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkFormatProperties2);
DECLARE_DESERIALISE_TYPE(VkFormatProperties3);
DECLARE_DESERIALISE_TYPE(VkFormatProperties4KHR);
DECLARE_DESERIALISE_TYPE(VkFragmentShadingRateAttachmentInfoKHR);
DECLARE_DESERIALISE_TYPE(VkFramebufferAttachmentImageInfo);
DECLARE_DESERIALISE_TYPE(VkFramebufferAttachmentsCreateInfo);
@@ -2199,6 +2285,7 @@ DECLARE_DESERIALISE_TYPE(VkImageCompressionControlEXT);
DECLARE_DESERIALISE_TYPE(VkImageCompressionPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkImageCopy2);
DECLARE_DESERIALISE_TYPE(VkImageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageCreateFlags2CreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImageDrmFormatModifierExplicitCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkImageDrmFormatModifierListCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkImageDrmFormatModifierPropertiesEXT);
@@ -2211,15 +2298,18 @@ DECLARE_DESERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
DECLARE_DESERIALISE_TYPE(VkImageResolve2);
DECLARE_DESERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkImageStencilUsageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageStencilUsage2CreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImageSubresource2);
DECLARE_DESERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImageToMemoryCopy);
DECLARE_DESERIALISE_TYPE(VkImageUsageFlags2CreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImageViewASTCDecodeModeEXT);
DECLARE_DESERIALISE_TYPE(VkImageViewCaptureDescriptorDataInfoEXT);
DECLARE_DESERIALISE_TYPE(VkImageViewCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageViewMinLodCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkImageViewSlicedCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkImageViewUsageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageViewUsage2CreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImportFenceFdInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImportMemoryFdInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImportSemaphoreFdInfoKHR);
@@ -2291,6 +2381,7 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedFlagsFeaturesKHR);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalBufferInfo);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalFenceInfo);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalImageFormatInfo);
@@ -2579,6 +2670,7 @@ DECLARE_DESERIALISE_TYPE(VkShaderCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkShaderModuleCreateInfo);
DECLARE_DESERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR);
DECLARE_DESERIALISE_TYPE(VkSharedPresentSurfaceCapabilities2KHR);
DECLARE_DESERIALISE_TYPE(VkSparseImageFormatProperties2);
DECLARE_DESERIALISE_TYPE(VkSparseImageMemoryRequirements2);
DECLARE_DESERIALISE_TYPE(VkSubmitInfo);
@@ -2814,6 +2906,18 @@ enum VkPipelineCreateFlagBits2 : uint64_t
{
};
enum VkFormatFeatureFlagBits4KHR : uint64_t
{
};
enum VkImageUsageFlagBits2KHR : uint64_t
{
};
enum VkImageCreateFlagBits2KHR : uint64_t
{
};
// enums
DECLARE_REFLECTION_ENUM(VkAccelerationStructureBuildTypeKHR);
@@ -2886,6 +2990,7 @@ DECLARE_REFLECTION_ENUM(VkFlagWithNoBits);
DECLARE_REFLECTION_ENUM(VkFormat);
DECLARE_REFLECTION_ENUM(VkFormatFeatureFlagBits);
DECLARE_REFLECTION_ENUM(VkFormatFeatureFlagBits2);
DECLARE_REFLECTION_ENUM(VkFormatFeatureFlagBits4KHR);
DECLARE_REFLECTION_ENUM(VkFragmentShadingRateCombinerOpKHR);
DECLARE_REFLECTION_ENUM(VkFramebufferCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkFrontFace);
@@ -2898,10 +3003,12 @@ DECLARE_REFLECTION_ENUM(VkImageAspectFlagBits);
DECLARE_REFLECTION_ENUM(VkImageCompressionFixedRateFlagBitsEXT);
DECLARE_REFLECTION_ENUM(VkImageCompressionFlagBitsEXT);
DECLARE_REFLECTION_ENUM(VkImageCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkImageCreateFlagBits2KHR);
DECLARE_REFLECTION_ENUM(VkImageLayout);
DECLARE_REFLECTION_ENUM(VkImageTiling);
DECLARE_REFLECTION_ENUM(VkImageType);
DECLARE_REFLECTION_ENUM(VkImageUsageFlagBits);
DECLARE_REFLECTION_ENUM(VkImageUsageFlagBits2KHR);
DECLARE_REFLECTION_ENUM(VkImageViewCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkImageViewType);
DECLARE_REFLECTION_ENUM(VkIndexType);
renderdoc/driver/vulkan/vk_core.cpp
+4
View File
@@ -1682,6 +1682,10 @@ static const VkExtensionProperties supportedExtensions[] = {
VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME,
VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION,
},
{
VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME,
VK_KHR_EXTENDED_FLAGS_SPEC_VERSION,
},
{
VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME,
VK_KHR_EXTERNAL_FENCE_SPEC_VERSION,
renderdoc/driver/vulkan/vk_core.h
+1
View File
@@ -1123,6 +1123,7 @@ private:
void PatchImageViewUsage(VkImageViewUsageCreateInfo *usage, VkFormat imgFormat,
VkSampleCountFlagBits samples);
void PatchImageCreateInfo(VkImageCreateInfo *pInfo, VkFormat *newViewFormats);
void PatchStencilUsageInfo(VkImageCreateInfo *pInfo);
VkIndirectPatchData FetchIndirectData(VkIndirectPatchType type, VkCommandBuffer commandBuffer,
VkBuffer dataBuffer, VkDeviceSize dataOffset, uint32_t count,
renderdoc/driver/vulkan/vk_info.cpp
+7 -6
View File
@@ -2611,17 +2611,18 @@ void VulkanCreationInfo::Image::Init(VulkanResourceManager *resourceMan, VulkanC
creationFlags = TextureCategory::NoFlags;
if(pCreateInfo->usage & VK_IMAGE_USAGE_SAMPLED_BIT)
VkImageUsageFlagBits2KHR usage = (VkImageUsageFlagBits2KHR)GetImageUsageFlags(pCreateInfo);
if(usage & VK_IMAGE_USAGE_SAMPLED_BIT)
creationFlags |= TextureCategory::ShaderRead;
if(pCreateInfo->usage &
(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT))
if(usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT))
creationFlags |= TextureCategory::ColorTarget;
if(pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
if(usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
creationFlags |= TextureCategory::DepthTarget;
if(pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT)
if(usage & VK_IMAGE_USAGE_STORAGE_BIT)
creationFlags |= TextureCategory::ShaderReadWrite;
cube = (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) ? true : false;
cube = (GetImageCreateFlags(pCreateInfo) & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) ? true : false;
address = 0;
}
renderdoc/driver/vulkan/vk_next_chains.cpp
+962 -958
View File
File diff suppressed because it is too large Load Diff
renderdoc/driver/vulkan/vk_resources.h
+1 -1
View File
@@ -949,7 +949,7 @@ struct ImageInfo
}
aspects = FormatImageAspects(format);
if(ci.usage & VK_IMAGE_USAGE_STORAGE_BIT)
if(GetImageUsageFlags(&ci) & VK_IMAGE_USAGE_STORAGE_BIT)
{
storage = true;
}
renderdoc/driver/vulkan/vk_serialise.cpp
+133 -9
View File
@@ -163,6 +163,7 @@ DECL_VKFLAG_EXT(VkPipelineStage, 2);
DECL_VKFLAG_EXT(VkAccess, 2);
DECL_VKFLAG_EXT(VkAccess, 3KHR);
DECL_VKFLAG_EXT(VkFormatFeature, 2);
DECL_VKFLAG_EXT(VkFormatFeature, 4KHR);
DECL_VKFLAG_EXT(VkGraphicsPipelineLibrary, EXT);
DECL_VKFLAG(VkRendering);
DECL_VKFLAG_EXT(VkPresentScaling, KHR);
@@ -180,6 +181,8 @@ DECL_VKFLAG_EXT(VkPipelineCreate, 2);
DECL_VKFLAG_EXT(VkImageCompression, EXT);
DECL_VKFLAG_EXT(VkImageCompressionFixedRate, EXT);
DECL_VKFLAG(VkHostImageCopy);
DECL_VKFLAG_EXT(VkImageUsage, 2KHR);
DECL_VKFLAG_EXT(VkImageCreate, 2KHR);
// serialise a member as flags - cast to the Bits enum for serialisation so the stringification
// picks up the bitfield and doesn't treat it as uint32_t. Then we rename the type back to the base
@@ -1244,6 +1247,20 @@ SERIALISE_VK_HANDLES();
PNEXT_STRUCT(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, \
VkRenderingInputAttachmentIndexInfo) \
\
/* VK_KHR_extended_flags */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR, \
VkPhysicalDeviceExtendedFlagsFeaturesKHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR, VkFormatProperties4KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR, \
VkImageCreateFlags2CreateInfoKHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR, \
VkImageStencilUsage2CreateInfoKHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR, \
VkImageUsageFlags2CreateInfoKHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR, VkImageViewUsage2CreateInfoKHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR, \
VkSharedPresentSurfaceCapabilities2KHR) \
\
/* VK_KHR_external_fence_capabilities */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, \
VkPhysicalDeviceExternalFenceInfo) \
@@ -2203,15 +2220,6 @@ SERIALISE_VK_HANDLES();
/* VK_KHR_shader_abort interaction */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR) \
\
/* VK_KHR_extended_flags */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR) \
\
/* VK_KHR_internally_synchronized_queues */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR) \
\
@@ -15703,6 +15711,115 @@ void Deserialise(const VkCustomResolveCreateInfoEXT &el)
delete[] el.pColorAttachmentFormats;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkPhysicalDeviceExtendedFlagsFeaturesKHR &el)
{
RDCASSERT(ser.IsReading() ||
el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(extendedFlags);
}
template <>
void Deserialise(const VkPhysicalDeviceExtendedFlagsFeaturesKHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkFormatProperties4KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkFormatFeatureFlags4KHR, linearTilingFeatures);
SERIALISE_MEMBER_VKFLAGS(VkFormatFeatureFlags4KHR, optimalTilingFeatures);
SERIALISE_MEMBER_VKFLAGS(VkFormatFeatureFlags4KHR, bufferFeatures);
}
template <>
void Deserialise(const VkFormatProperties4KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageCreateFlags2CreateInfoKHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkImageCreateFlags2KHR, flags);
}
template <>
void Deserialise(const VkImageCreateFlags2CreateInfoKHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageStencilUsage2CreateInfoKHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkImageUsageFlags2KHR, stencilUsage);
}
template <>
void Deserialise(const VkImageStencilUsage2CreateInfoKHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageUsageFlags2CreateInfoKHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkImageUsageFlags2KHR, usage);
}
template <>
void Deserialise(const VkImageUsageFlags2CreateInfoKHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageViewUsage2CreateInfoKHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkImageUsageFlags2KHR, usage);
}
template <>
void Deserialise(const VkImageViewUsage2CreateInfoKHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkSharedPresentSurfaceCapabilities2KHR &el)
{
RDCASSERT(ser.IsReading() ||
el.sType == VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkImageUsageFlags2KHR, sharedPresentSupportedUsageFlags);
}
template <>
void Deserialise(const VkSharedPresentSurfaceCapabilities2KHR &el)
{
DeserialiseNext(el.pNext);
}
// pNext structs - always have deserialise for the next chain
INSTANTIATE_SERIALISE_TYPE(VkAccelerationStructureBuildGeometryInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkAccelerationStructureBuildSizesInfoKHR);
@@ -15847,6 +15964,7 @@ INSTANTIATE_SERIALISE_TYPE(VkFenceGetFdInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkFilterCubicImageViewImageFormatPropertiesEXT);
INSTANTIATE_SERIALISE_TYPE(VkFormatProperties2);
INSTANTIATE_SERIALISE_TYPE(VkFormatProperties3);
INSTANTIATE_SERIALISE_TYPE(VkFormatProperties4KHR);
INSTANTIATE_SERIALISE_TYPE(VkFragmentShadingRateAttachmentInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkFramebufferAttachmentImageInfo);
INSTANTIATE_SERIALISE_TYPE(VkFramebufferAttachmentsCreateInfo);
@@ -15862,6 +15980,7 @@ INSTANTIATE_SERIALISE_TYPE(VkImageCompressionControlEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageCompressionPropertiesEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageCopy2);
INSTANTIATE_SERIALISE_TYPE(VkImageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageCreateFlags2CreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImageDrmFormatModifierExplicitCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageDrmFormatModifierListCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageDrmFormatModifierPropertiesEXT);
@@ -15874,13 +15993,16 @@ INSTANTIATE_SERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageResolve2);
INSTANTIATE_SERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkImageStencilUsageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageStencilUsage2CreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImageSubresource2);
INSTANTIATE_SERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImageToMemoryCopy);
INSTANTIATE_SERIALISE_TYPE(VkImageUsageFlags2CreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImageViewASTCDecodeModeEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageViewCaptureDescriptorDataInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageViewCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageViewUsageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageViewUsage2CreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImportFenceFdInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImportMemoryFdInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImportSemaphoreFdInfoKHR);
@@ -15955,6 +16077,7 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedFlagsFeaturesKHR);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalBufferInfo);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalFenceInfo);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalImageFormatInfo);
@@ -16240,6 +16363,7 @@ INSTANTIATE_SERIALISE_TYPE(VkShaderCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkShaderModuleCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR);
INSTANTIATE_SERIALISE_TYPE(VkSharedPresentSurfaceCapabilities2KHR);
INSTANTIATE_SERIALISE_TYPE(VkSparseImageFormatProperties2);
INSTANTIATE_SERIALISE_TYPE(VkSparseImageMemoryRequirements2);
INSTANTIATE_SERIALISE_TYPE(VkSubmitInfo);
renderdoc/driver/vulkan/vk_stringise.cpp
+73
View File
@@ -4390,6 +4390,15 @@ rdcstr DoStringise(const VkFormatFeatureFlagBits2 &el)
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkFormatFeatureFlagBits4KHR &el)
{
BEGIN_BITFIELD_STRINGISE(VkFormatFeatureFlagBits4KHR);
{
}
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkGraphicsPipelineLibraryFlagBitsEXT &el)
{
@@ -4600,6 +4609,70 @@ rdcstr DoStringise(const VkPipelineCreateFlagBits2 &el)
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkImageUsageFlagBits2KHR &el)
{
BEGIN_BITFIELD_STRINGISE(VkImageUsageFlagBits2KHR);
{
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_TRANSFER_SRC_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_TRANSFER_DST_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_SAMPLED_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_STORAGE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_COLOR_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_TRANSIENT_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_INPUT_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_FRAGMENT_DENSITY_MAP_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_DECODE_DST_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_DECODE_DPB_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_ENCODE_DPB_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_INVOCATION_MASK_BIT_HUAWEI);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_SAMPLE_WEIGHT_BIT_QCOM);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_SAMPLE_BLOCK_MATCH_BIT_QCOM);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_HOST_TRANSFER_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_TENSOR_ALIASING_BIT_ARM);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_USAGE_2_TILE_MEMORY_BIT_QCOM);
}
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkImageCreateFlagBits2KHR &el)
{
BEGIN_BITFIELD_STRINGISE(VkImageCreateFlagBits2KHR);
{
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SPARSE_BINDING_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SPARSE_RESIDENCY_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SPARSE_ALIASED_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_MUTABLE_FORMAT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_CUBE_COMPATIBLE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_2D_ARRAY_COMPATIBLE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_EXTENDED_USAGE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_DISJOINT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_ALIAS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_PROTECTED_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_CORNER_SAMPLED_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_SUBSAMPLED_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_2D_VIEW_COMPATIBLE_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_IMAGE_CREATE_2_VIDEO_PROFILE_INDEPENDENT_BIT_KHR);
}
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkExtent3D &el)
{
renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp
+7
View File
@@ -3787,6 +3787,13 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
CHECK_PHYS_EXT_FEATURE(imageSlicedViewOf3D);
}
END_PHYS_EXT_CHECK();
BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceExtendedFlagsFeaturesKHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR);
{
CHECK_PHYS_EXT_FEATURE(extendedFlags);
}
END_PHYS_EXT_CHECK();
}
if(availFeatures.depthClamp)
renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp
+56 -31
View File
@@ -89,61 +89,80 @@ void ClampPhysDevAPIVersion(VkPhysicalDeviceProperties *pProperties, VkPhysicalD
pProperties->apiVersion = VK_API_VERSION_1_4;
}
void WrappedVulkan::PatchStencilUsageInfo(VkImageCreateInfo *info)
{
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
VkImageStencilUsage2CreateInfoKHR *separateStencilUsage2 =
(VkImageStencilUsage2CreateInfoKHR *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR);
if(separateStencilUsage2)
{
separateStencilUsage2->stencilUsage |= VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
separateStencilUsage2->stencilUsage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage2->stencilUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
else if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
separateStencilUsage->stencilUsage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
}
void WrappedVulkan::PatchImageCreateInfo(VkImageCreateInfo *info, VkFormat *newViewFormatsTempMem)
{
info->usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
VkImageUsageFlags2KHR usage = GetImageUsageFlags(info);
VkImageCreateFlags2KHR flags = GetImageCreateFlags(info);
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(IsYUVFormat(info->format))
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(IsCaptureMode(m_State))
{
if(!IsDepthOrStencilFormat(info->format))
{
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
info->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
else
{
info->usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
}
info->flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
info->flags |= DefaultImageCreateFlags();
flags |= DefaultImageCreateFlags();
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |=
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
PatchStencilUsageInfo(info);
// similarly for the image format list for MSAA textures, add the UINT cast format we will need
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
@@ -188,6 +207,9 @@ void WrappedVulkan::PatchImageCreateInfo(VkImageCreateInfo *info, VkFormat *newV
newViewFormatsTempMem += formatListInfo->viewFormatCount;
}
}
SetImageUsageFlags(info, usage);
SetImageCreateFlags(info, flags);
}
void WrappedVulkan::vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
@@ -321,8 +343,11 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceImageFormatProperties2(
// suddenly report as unsupported (all required formats must support these usages), so it can only
// make an optional format unsupported which is what we want.
VkPhysicalDeviceImageFormatInfo2 info = *pImageFormatInfo;
info.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT;
VkImageUsageFlags2KHR usage = GetImageUsageFlags(&info);
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT;
SetImageUsageFlags(&info, usage);
VkResult vkr = ObjDisp(physicalDevice)
->GetPhysicalDeviceImageFormatProperties2(Unwrap(physicalDevice), &info,
renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp
+15 -9
View File
@@ -884,31 +884,37 @@ VkResult WrappedVulkan::vkCreateSampler(VkDevice device, const VkSamplerCreateIn
void WrappedVulkan::PatchAttachment(VkFramebufferAttachmentImageInfo *att, VkFormat imgFormat,
VkSampleCountFlagBits samples)
{
VkImageUsageFlags2KHR usage = GetImageUsageFlags(att);
VkImageCreateFlags2KHR flags = GetImageCreateFlags(att);
// this matches the mutations we do to images, so see vkCreateImage
att->usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
att->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
att->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(IsYUVFormat(imgFormat))
att->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(samples != VK_SAMPLE_COUNT_1_BIT)
{
att->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
att->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(!IsDepthOrStencilFormat(imgFormat))
{
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
att->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
else
{
att->usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
att->flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
SetImageUsageFlags(att, usage);
SetImageCreateFlags(att, flags);
}
template <typename SerialiserType>
renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp
+85 -80
View File
@@ -2499,12 +2499,13 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
{
VkImage img = VK_NULL_HANDLE;
VkImageUsageFlags origusage = CreateInfo.usage;
VkImageUsageFlags2KHR origusage = GetImageUsageFlags(&CreateInfo);
// ensure we can always display and copy from/to textures
CreateInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
CreateInfo.usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
VkImageUsageFlags2KHR patchedUsage = origusage;
patchedUsage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
patchedUsage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(CreateInfo.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT)
CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
@@ -2517,14 +2518,16 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
queueFamiles[q] = m_QueueRemapping[queueFamiles[q]][0].family;
}
VkImageUsageFlags2KHR flags = GetImageCreateFlags(&CreateInfo);
// need to be able to mutate the format for YUV textures
if(IsYUVFormat(CreateInfo.format))
CreateInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
// ensure we can cast multisampled images, for copying to arrays
if((int)CreateInfo.samples > 1)
{
CreateInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
// colour targets we do a simple compute copy, for depth-stencil we need
// to take a slower path that uses drawing
@@ -2535,24 +2538,24 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
// capability (and it might be the bug we're trying to work around by disabling the
// pipeline)
if(GetShaderCache()->IsBuffer2MSSupported())
CreateInfo.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
CreateInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
patchedUsage |= VK_IMAGE_USAGE_STORAGE_BIT;
patchedUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
}
else
{
CreateInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
patchedUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
// create non-subsampled image to be able to copy its content
CreateInfo.flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
CreateInfo.flags |= DefaultImageCreateFlags();
flags |= DefaultImageCreateFlags();
APIProps.YUVTextures |= IsYUVFormat(CreateInfo.format);
const bool isSparse = (CreateInfo.flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT |
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) != 0;
const bool isSparse =
(flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) != 0;
if(isSparse)
{
@@ -2560,21 +2563,7 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
}
// we search for the separate stencil usage struct now that it's in patchable memory
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
&CreateInfo, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
separateStencilUsage->stencilUsage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(CreateInfo.samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
PatchStencilUsageInfo(&CreateInfo);
rdcarray<VkFormat> patchedFormatList;
@@ -2648,11 +2637,11 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
};
// pass creation info
queryBase.flags = CreateInfo.flags;
queryBase.flags = (VkImageCreateFlags)flags;
queryBase.format = CreateInfo.format;
queryBase.tiling = CreateInfo.tiling;
queryBase.type = CreateInfo.imageType;
queryBase.usage = CreateInfo.usage;
queryBase.usage = (VkImageUsageFlags)patchedUsage;
// pass image format list, if the application did
VkImageFormatListCreateInfo *appFormatInfo = (VkImageFormatListCreateInfo *)FindNextStruct(
@@ -2665,6 +2654,27 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
queryBase.pNext = &formatInfo;
}
// ditto for expanded usage/flags
VkImageCreateFlags2CreateInfoKHR *appFlags2 =
(VkImageCreateFlags2CreateInfoKHR *)FindNextStruct(
&CreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR);
VkImageCreateFlags2CreateInfoKHR flags2;
if(appFlags2)
{
flags2 = *appFlags2;
flags2.pNext = (void *)queryBase.pNext;
queryBase.pNext = &flags2;
}
VkImageUsageFlags2CreateInfoKHR *appUsage2 = (VkImageUsageFlags2CreateInfoKHR *)FindNextStruct(
&CreateInfo, VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR);
VkImageUsageFlags2CreateInfoKHR usage2;
if(appUsage2)
{
usage2 = *appUsage2;
usage2.pNext = (void *)queryBase.pNext;
queryBase.pNext = &usage2;
}
for(uint32_t i = 0; i < 32; i++)
{
VkExternalMemoryHandleTypeFlagBits checkBit = VkExternalMemoryHandleTypeFlagBits(1U << i);
@@ -2737,13 +2747,16 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
VkImageCreateInfo patched = CreateInfo;
SetImageUsageFlags(&patched, patchedUsage);
SetImageCreateFlags(&patched, flags);
byte *tempMem = GetTempMemory(GetNextPatchSize(patched.pNext));
UnwrapNextChain(m_State, "VkImageCreateInfo", tempMem, (VkBaseInStructure *)&patched);
VkResult ret = ObjDisp(device)->CreateImage(Unwrap(device), &patched, NULL, &img);
CreateInfo.usage = origusage;
SetImageUsageFlags(&CreateInfo, origusage);
if(ret != VK_SUCCESS)
{
@@ -2803,31 +2816,31 @@ bool WrappedVulkan::Serialise_vkCreateImage(SerialiserType &ser, VkDevice device
{
prefix = CreateInfo.arrayLayers > 1 ? "1D Array Image" : "1D Image";
if(CreateInfo.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
if(origusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
prefix = "1D Color Attachment";
else if(CreateInfo.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
else if(origusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
prefix = "1D " + depth + " Attachment";
}
else if(CreateInfo.imageType == VK_IMAGE_TYPE_2D)
{
prefix = CreateInfo.arrayLayers > 1 ? "2D Array Image" : "2D Image";
if(CreateInfo.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
if(origusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
prefix = "2D Color Attachment";
else if(CreateInfo.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
else if(origusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
prefix = "2D " + depth + " Attachment";
else if(CreateInfo.usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT)
else if(origusage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT)
prefix = "2D Fragment Density Map Attachment";
else if(CreateInfo.usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR)
else if(origusage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR)
prefix = "2D Fragment Shading Rate Attachment";
}
else if(CreateInfo.imageType == VK_IMAGE_TYPE_3D)
{
prefix = "3D Image";
if(CreateInfo.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
if(origusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
prefix = "3D Color Attachment";
else if(CreateInfo.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
else if(origusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
prefix = "3D " + depth + " Attachment";
}
@@ -2853,24 +2866,27 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
// if you change any properties here, ensure you also update
// vkGetDeviceImageMemoryRequirementsKHR
createInfo_adjusted.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
VkImageUsageFlags2KHR usage = GetImageUsageFlags(&createInfo_adjusted);
VkImageCreateFlags2KHR flags = GetImageCreateFlags(&createInfo_adjusted);
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
// TEMP HACK: Until we define a portable fake hardware, need to match the requirements for usage
// on replay, so that the memory requirements are the same
if(IsCaptureMode(m_State))
{
createInfo_adjusted.usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
createInfo_adjusted.usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
// need to be able to mutate the format for YUV textures
if(IsYUVFormat(createInfo_adjusted.format))
createInfo_adjusted.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(createInfo_adjusted.samples != VK_SAMPLE_COUNT_1_BIT)
{
createInfo_adjusted.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
createInfo_adjusted.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
// TEMP HACK: matching replay requirements
if(IsCaptureMode(m_State))
@@ -2880,21 +2896,21 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
// need to check the debug manager here since we might be creating this internal image from
// its constructor
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
createInfo_adjusted.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
createInfo_adjusted.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_STORAGE_BIT;
usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
}
else
{
createInfo_adjusted.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
}
// create non-subsampled image to be able to copy its content
createInfo_adjusted.flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
if(IsCaptureMode(m_State))
createInfo_adjusted.flags |= DefaultImageCreateFlags();
flags |= DefaultImageCreateFlags();
size_t tempMemSize = GetNextPatchSize(createInfo_adjusted.pNext);
@@ -2914,25 +2930,7 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
UnwrapNextChain(m_State, "VkImageCreateInfo", tempMem, (VkBaseInStructure *)&createInfo_adjusted);
// we search for the separate stencil usage struct now that it's in patchable memory
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
&createInfo_adjusted, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
createInfo_adjusted.usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
createInfo_adjusted.usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(createInfo_adjusted.samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |=
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
PatchStencilUsageInfo(&createInfo_adjusted);
// similarly for the image format list for MSAA textures, add the UINT cast format we will need
if(createInfo_adjusted.samples != VK_SAMPLE_COUNT_1_BIT)
@@ -2977,6 +2975,9 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
}
}
SetImageUsageFlags(&createInfo_adjusted, usage);
SetImageCreateFlags(&createInfo_adjusted, flags);
VkResult ret;
SERIALISE_TIME_CALL(
ret = ObjDisp(device)->CreateImage(Unwrap(device), &createInfo_adjusted, NULL, pImage));
@@ -2985,8 +2986,8 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
{
ResourceId id = GetResourceManager()->WrapResource(ResourceId(), Unwrap(device), *pImage);
const bool isSparse = (pCreateInfo->flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT |
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) != 0;
const bool isSparse =
(flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) != 0;
if(IsCaptureMode(m_State))
{
@@ -3023,7 +3024,7 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
ResourceInfo &resInfo = *record->resInfo;
resInfo.imageInfo = ImageInfo(*pCreateInfo);
record->storable = (pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) != 0;
record->storable = (GetImageUsageFlags(pCreateInfo) & VK_IMAGE_USAGE_STORAGE_BIT) != 0;
bool isLinear = (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR);
@@ -3180,7 +3181,7 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
{
uint32_t pageByteSize = resInfo.memreqs.alignment & 0xFFFFFFFFu;
if(pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)
if(flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)
{
// must record image and page dimension, and create page tables
uint32_t numreqs = 8;
@@ -3256,28 +3257,32 @@ VkResult WrappedVulkan::vkCreateImage(VkDevice device, const VkImageCreateInfo *
return ret;
}
void WrappedVulkan::PatchImageViewUsage(VkImageViewUsageCreateInfo *usage, VkFormat imgFormat,
void WrappedVulkan::PatchImageViewUsage(VkImageViewUsageCreateInfo *usageInfo, VkFormat imgFormat,
VkSampleCountFlagBits samples)
{
VkImageUsageFlags2KHR usage = GetImageViewUsageFlags(usageInfo);
// this matches the mutations we do to images, so see vkCreateImage
usage->usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usage->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usage->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
if(samples != VK_SAMPLE_COUNT_1_BIT)
{
usage->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
if(!IsDepthOrStencilFormat(imgFormat))
{
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
usage->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
else
{
usage->usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
SetImageUsageFlags(usageInfo, usage);
}
// Image view functions