diff --git a/renderdoc/driver/vulkan/official/vulkan_core.h b/renderdoc/driver/vulkan/official/vulkan_core.h index 246ae72bd..f41ccf4a4 100644 --- a/renderdoc/driver/vulkan/official/vulkan_core.h +++ b/renderdoc/driver/vulkan/official/vulkan_core.h @@ -44,7 +44,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 128 +#define VK_HEADER_VERSION 129 #define VK_NULL_HANDLE 0 @@ -145,10 +145,11 @@ typedef enum VkResult { VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, VK_ERROR_FRAGMENTATION_EXT = -1000161000, VK_ERROR_NOT_PERMITTED_EXT = -1000174001, - VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, VK_RESULT_END_RANGE = VK_INCOMPLETE, VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), @@ -516,7 +517,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000, VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, @@ -533,6 +533,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, @@ -613,6 +618,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -1657,7 +1663,8 @@ typedef enum VkBufferCreateFlagBits { VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferCreateFlagBits; typedef VkFlags VkBufferCreateFlags; @@ -1676,7 +1683,8 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferUsageFlagBits; typedef VkFlags VkBufferUsageFlags; @@ -4060,6 +4068,8 @@ typedef VkFlags VkPeerMemoryFeatureFlags; typedef enum VkMemoryAllocateFlagBits { VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004, VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkMemoryAllocateFlagBits; @@ -6680,6 +6690,61 @@ typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { +#define VK_KHR_buffer_device_address 1 +typedef uint64_t VkDeviceAddress; +#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; + +typedef struct VkBufferDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfoKHR; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfoKHR; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfoKHR; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfoKHR; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfoKHR* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfoKHR* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo); +#endif + + #define VK_KHR_pipeline_executable_properties 1 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" @@ -9811,7 +9876,6 @@ typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { #define VK_EXT_buffer_device_address 1 -typedef uint64_t VkDeviceAddress; #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { @@ -9824,11 +9888,7 @@ typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; -typedef struct VkBufferDeviceAddressInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfoEXT; +typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT; typedef struct VkBufferDeviceAddressCreateInfoEXT { VkStructureType sType; @@ -9836,12 +9896,12 @@ typedef struct VkBufferDeviceAddressCreateInfoEXT { VkDeviceAddress deviceAddress; } VkBufferDeviceAddressCreateInfoEXT; -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( VkDevice device, - const VkBufferDeviceAddressInfoEXT* pInfo); + const VkBufferDeviceAddressInfoKHR* pInfo); #endif diff --git a/renderdoc/driver/vulkan/vk.xml b/renderdoc/driver/vulkan/vk.xml index 26ff4cc7d..9d98e9d2b 100644 --- a/renderdoc/driver/vulkan/vk.xml +++ b/renderdoc/driver/vulkan/vk.xml @@ -154,7 +154,7 @@ server. // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 128 +#define VK_HEADER_VERSION 129 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -3865,6 +3865,13 @@ typedef void CAMetalLayer; const void* pNext float priority + + VkStructureType sType + void* pNext + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + VkStructureType sType void* pNext @@ -3872,12 +3879,18 @@ typedef void CAMetalLayer; VkBool32 bufferDeviceAddressCaptureReplay VkBool32 bufferDeviceAddressMultiDevice - - - VkStructureType sType + + + VkStructureType sType const void* pNext VkBuffer buffer + + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + VkStructureType sType const void* pNext @@ -4246,6 +4259,16 @@ typedef void CAMetalLayer; void* pNext uint32_t requiredSubgroupSize + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkStructureType sType void* pNext @@ -5740,7 +5763,7 @@ typedef void CAMetalLayer; all sname:VkQueue objects created from pname:device - + VkResult vkAllocateMemory VkDevice device const VkMemoryAllocateInfo* pAllocateInfo @@ -5791,7 +5814,7 @@ typedef void CAMetalLayer; VkBuffer buffer VkMemoryRequirements* pMemoryRequirements - + VkResult vkBindBufferMemory VkDevice device VkBuffer buffer @@ -5940,7 +5963,7 @@ typedef void CAMetalLayer; uint32_t firstQuery uint32_t queryCount - + VkResult vkCreateBuffer VkDevice device const VkBufferCreateInfo* pCreateInfo @@ -7127,7 +7150,7 @@ typedef void CAMetalLayer; VkPeerMemoryFeatureFlags* pPeerMemoryFeatures - + VkResult vkBindBufferMemory2 VkDevice device uint32_t bindInfoCount @@ -7886,10 +7909,16 @@ typedef void CAMetalLayer; VkImageDrmFormatModifierPropertiesEXT* pProperties - VkDeviceAddress vkGetBufferDeviceAddressEXT + uint64_t vkGetBufferOpaqueCaptureAddressKHR VkDevice device - const VkBufferDeviceAddressInfoEXT* pInfo + const VkBufferDeviceAddressInfoKHR* pInfo + + VkDeviceAddress vkGetBufferDeviceAddressKHR + VkDevice device + const VkBufferDeviceAddressInfoKHR* pInfo + + VkResult vkCreateHeadlessSurfaceEXT VkInstance instance @@ -7949,6 +7978,11 @@ typedef void CAMetalLayer; VkPerformanceParameterTypeINTEL parameter VkPerformanceValueINTEL* pValue + + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR + VkDevice device + const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo + VkResult vkGetPipelineExecutablePropertiesKHR VkDevice device @@ -10367,6 +10401,7 @@ typedef void CAMetalLayer; + @@ -11399,17 +11434,17 @@ typedef void CAMetalLayer; - + - - + + - - - + + + @@ -11540,10 +11575,28 @@ typedef void CAMetalLayer; - + - - + + + + + + + + + + + + + + + + + + + + @@ -11834,5 +11887,23 @@ typedef void CAMetalLayer; + + + + + + + + + + + + + + + + + + diff --git a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp index 873cd0851..9a51b9eec 100644 --- a/renderdoc/driver/vulkan/vk_bindless_feedback.cpp +++ b/renderdoc/driver/vulkan/vk_bindless_feedback.cpp @@ -37,7 +37,7 @@ struct feedbackData void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, const std::map &offsetMap, VkDeviceAddress addr, - std::vector &modSpirv) + bool bufferAddressKHR, std::vector &modSpirv) { rdcspv::Editor editor(modSpirv); @@ -129,22 +129,23 @@ void AnnotateShader(const SPIRVPatchData &patchData, const char *entryName, if(useBufferAddress) { // add the extension - editor.AddExtension("SPV_EXT_physical_storage_buffer"); + editor.AddExtension(bufferAddressKHR ? "SPV_KHR_physical_storage_buffer" + : "SPV_EXT_physical_storage_buffer"); // change the memory model to physical storage buffer 64 rdcspv::Iter it = editor.Begin(rdcspv::Section::MemoryModel); rdcspv::OpMemoryModel model(it); - model.addressingModel = rdcspv::AddressingModel::PhysicalStorageBuffer64EXT; + model.addressingModel = rdcspv::AddressingModel::PhysicalStorageBuffer64; it = model; // add capabilities - editor.AddCapability(rdcspv::Capability::PhysicalStorageBufferAddressesEXT); + editor.AddCapability(rdcspv::Capability::PhysicalStorageBufferAddresses); editor.AddCapability(rdcspv::Capability::Int64); // declare the address constants and make our pointers physical storage buffer pointers bufferAddressConst = editor.AddConstantImmediate(addr); uint32ptrtype = - editor.DeclareType(rdcspv::Pointer(uint32ID, rdcspv::StorageClass::PhysicalStorageBufferEXT)); + editor.DeclareType(rdcspv::Pointer(uint32ID, rdcspv::StorageClass::PhysicalStorageBuffer)); editor.SetName(bufferAddressConst, "__rd_feedbackAddress"); @@ -526,8 +527,11 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) // if it actually has any data in it later. DynamicUsedBinds &result = m_BindlessFeedback.Usage[eventId]; - bool useBufferAddress = - ObjDisp(m_Device)->GetBufferDeviceAddressEXT && m_pDriver->GetDeviceFeatures().shaderInt64; + bool useBufferAddress = (m_pDriver->GetExtensions(NULL).ext_KHR_buffer_device_address || + m_pDriver->GetExtensions(NULL).ext_EXT_buffer_device_address) && + m_pDriver->GetDeviceFeatures().shaderInt64; + + bool useBufferAddressKHR = m_pDriver->GetExtensions(NULL).ext_KHR_buffer_device_address; const VulkanRenderState &state = m_pDriver->m_RenderState; VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo; @@ -622,10 +626,16 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) if(useBufferAddress) { - VkBufferDeviceAddressInfoEXT getAddressInfo = {VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT}; + RDCCOMPILE_ASSERT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR == + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, + "KHR and EXT buffer_device_address should be interchangeable here."); + VkBufferDeviceAddressInfoKHR getAddressInfo = {VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR}; getAddressInfo.buffer = m_BindlessFeedback.FeedbackBuffer.buf; - bufferAddress = m_pDriver->vkGetBufferDeviceAddressEXT(dev, &getAddressInfo); + if(useBufferAddressKHR) + bufferAddress = m_pDriver->vkGetBufferDeviceAddressKHR(dev, &getAddressInfo); + else + bufferAddress = m_pDriver->vkGetBufferDeviceAddressEXT(dev, &getAddressInfo); } else { @@ -704,7 +714,8 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) std::vector modSpirv = moduleInfo.spirv.GetSPIRV(); - AnnotateShader(*pipeInfo.shaders[5].patchData, stage.pName, offsetMap, bufferAddress, modSpirv); + AnnotateShader(*pipeInfo.shaders[5].patchData, stage.pName, offsetMap, bufferAddress, + useBufferAddressKHR, modSpirv); moduleCreateInfo.pCode = modSpirv.data(); moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t); @@ -729,7 +740,7 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId) std::vector modSpirv = moduleInfo.spirv.GetSPIRV(); AnnotateShader(*pipeInfo.shaders[idx].patchData, stage.pName, offsetMap, bufferAddress, - modSpirv); + useBufferAddressKHR, modSpirv); moduleCreateInfo.pCode = modSpirv.data(); moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t); diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index a91d6793f..5fd9c79d3 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -180,7 +180,7 @@ void GPUBuffer::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size, u bufInfo.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; if(flags & eGPUBufferAddressable) - bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT; + bufInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR; VkResult vkr = driver->vkCreateBuffer(dev, &bufInfo, NULL, &buf); RDCASSERTEQUAL(vkr, VK_SUCCESS); diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 749cb9c37..947b8e181 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -660,9 +660,10 @@ DECLARE_REFLECTION_STRUCT(VkBindImagePlaneMemoryInfo); DECLARE_REFLECTION_STRUCT(VkBindSparseInfo); DECLARE_REFLECTION_STRUCT(VkBufferCreateInfo); DECLARE_REFLECTION_STRUCT(VkBufferDeviceAddressCreateInfoEXT); -DECLARE_REFLECTION_STRUCT(VkBufferDeviceAddressInfoEXT); +DECLARE_REFLECTION_STRUCT(VkBufferDeviceAddressInfoKHR); DECLARE_REFLECTION_STRUCT(VkBufferMemoryBarrier); DECLARE_REFLECTION_STRUCT(VkBufferMemoryRequirementsInfo2); +DECLARE_REFLECTION_STRUCT(VkBufferOpaqueCaptureAddressCreateInfoKHR); DECLARE_REFLECTION_STRUCT(VkBufferViewCreateInfo); DECLARE_REFLECTION_STRUCT(VkCalibratedTimestampInfoEXT); DECLARE_REFLECTION_STRUCT(VkCommandBufferAllocateInfo); @@ -703,6 +704,7 @@ DECLARE_REFLECTION_STRUCT(VkDeviceGroupPresentInfoKHR); DECLARE_REFLECTION_STRUCT(VkDeviceGroupRenderPassBeginInfo); DECLARE_REFLECTION_STRUCT(VkDeviceGroupSubmitInfo); DECLARE_REFLECTION_STRUCT(VkDeviceGroupSwapchainCreateInfoKHR); +DECLARE_REFLECTION_STRUCT(VkDeviceMemoryOpaqueCaptureAddressInfoKHR); DECLARE_REFLECTION_STRUCT(VkDeviceQueueCreateInfo); DECLARE_REFLECTION_STRUCT(VkDeviceQueueGlobalPriorityCreateInfoEXT); DECLARE_REFLECTION_STRUCT(VkDeviceQueueInfo2); @@ -762,17 +764,19 @@ DECLARE_REFLECTION_STRUCT(VkMemoryDedicatedAllocateInfo); DECLARE_REFLECTION_STRUCT(VkMemoryDedicatedRequirements); DECLARE_REFLECTION_STRUCT(VkMemoryFdPropertiesKHR); DECLARE_REFLECTION_STRUCT(VkMemoryGetFdInfoKHR); +DECLARE_REFLECTION_STRUCT(VkMemoryOpaqueCaptureAddressAllocateInfoKHR); DECLARE_REFLECTION_STRUCT(VkMemoryPriorityAllocateInfoEXT); DECLARE_REFLECTION_STRUCT(VkMemoryRequirements2); DECLARE_REFLECTION_STRUCT(VkMultisamplePropertiesEXT); DECLARE_REFLECTION_STRUCT(VkPastPresentationTimingGOOGLE); -DECLARE_REFLECTION_STRUCT(VkPerformanceCounterKHR); DECLARE_REFLECTION_STRUCT(VkPerformanceCounterDescriptionKHR); +DECLARE_REFLECTION_STRUCT(VkPerformanceCounterKHR); DECLARE_REFLECTION_STRUCT(VkPerformanceQuerySubmitInfoKHR); DECLARE_REFLECTION_STRUCT(VkPhysicalDevice16BitStorageFeatures); DECLARE_REFLECTION_STRUCT(VkPhysicalDevice8BitStorageFeaturesKHR); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceASTCDecodeFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); +DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceBufferDeviceAddressFeaturesKHR); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceCoherentMemoryFeaturesAMD); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceConditionalRenderingFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceConservativeRasterizationPropertiesEXT); @@ -941,6 +945,7 @@ DECLARE_DESERIALISE_TYPE(VkBindSparseInfo); DECLARE_DESERIALISE_TYPE(VkBufferCreateInfo); DECLARE_DESERIALISE_TYPE(VkBufferMemoryBarrier); DECLARE_DESERIALISE_TYPE(VkBufferMemoryRequirementsInfo2); +DECLARE_DESERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfoKHR); DECLARE_DESERIALISE_TYPE(VkBufferViewCreateInfo); DECLARE_DESERIALISE_TYPE(VkCalibratedTimestampInfoEXT); DECLARE_DESERIALISE_TYPE(VkCommandBufferAllocateInfo); @@ -981,6 +986,7 @@ DECLARE_DESERIALISE_TYPE(VkDeviceGroupPresentInfoKHR); DECLARE_DESERIALISE_TYPE(VkDeviceGroupRenderPassBeginInfo); DECLARE_DESERIALISE_TYPE(VkDeviceGroupSubmitInfo); DECLARE_DESERIALISE_TYPE(VkDeviceGroupSwapchainCreateInfoKHR); +DECLARE_DESERIALISE_TYPE(VkDeviceMemoryOpaqueCaptureAddressInfoKHR); DECLARE_DESERIALISE_TYPE(VkDeviceQueueCreateInfo); DECLARE_DESERIALISE_TYPE(VkDeviceQueueGlobalPriorityCreateInfoEXT); DECLARE_DESERIALISE_TYPE(VkDeviceQueueInfo2); @@ -1039,6 +1045,7 @@ DECLARE_DESERIALISE_TYPE(VkMemoryDedicatedAllocateInfo); DECLARE_DESERIALISE_TYPE(VkMemoryDedicatedRequirements); DECLARE_DESERIALISE_TYPE(VkMemoryFdPropertiesKHR); DECLARE_DESERIALISE_TYPE(VkMemoryGetFdInfoKHR); +DECLARE_DESERIALISE_TYPE(VkMemoryOpaqueCaptureAddressAllocateInfoKHR); DECLARE_DESERIALISE_TYPE(VkMemoryPriorityAllocateInfoEXT); DECLARE_DESERIALISE_TYPE(VkMemoryRequirements2); DECLARE_DESERIALISE_TYPE(VkMultisamplePropertiesEXT); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 59821d7b8..3332da3d0 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -1257,6 +1257,36 @@ VkResult WrappedVulkan::FilterDeviceExtensionProperties(VkPhysicalDevice physDev continue; } + if(!strcmp(it->extensionName, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) + { + // require GPDP2 + if(instDevInfo->ext_KHR_get_physical_device_properties2) + { + VkPhysicalDeviceBufferDeviceAddressFeaturesKHR bufaddr = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR}; + VkPhysicalDeviceFeatures2 base = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}; + base.pNext = &bufaddr; + ObjDisp(physDev)->GetPhysicalDeviceFeatures2(Unwrap(physDev), &base); + + if(bufaddr.bufferDeviceAddressCaptureReplay) + { + // supported + ++it; + continue; + } + else + { + RDCWARN( + "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.bufferDeviceAddressCaptureReplay " + "is false, can't support capture of VK_KHR_buffer_device_address"); + } + } + + // if it wasn't supported, remove the extension + it = filtered.erase(it); + continue; + } + ++it; } diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 212c34da3..a552a02e2 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -2208,4 +2208,11 @@ public: const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses); VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo); void vkReleaseProfilingLockKHR(VkDevice device); + + // VK_KHR_buffer_device_address + + VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, VkBufferDeviceAddressInfoKHR *pInfo); + uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, VkBufferDeviceAddressInfoKHR *pInfo); + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, + VkDeviceMemoryOpaqueCaptureAddressInfoKHR *pInfo); }; diff --git a/renderdoc/driver/vulkan/vk_dispatch_defs.h b/renderdoc/driver/vulkan/vk_dispatch_defs.h index 371e1eb4a..f4d5ee7c1 100644 --- a/renderdoc/driver/vulkan/vk_dispatch_defs.h +++ b/renderdoc/driver/vulkan/vk_dispatch_defs.h @@ -514,6 +514,11 @@ struct VkDevDispatchTable PFN_vkWaitSemaphoresKHR WaitSemaphoresKHR; PFN_vkSignalSemaphoreKHR SignalSemaphoreKHR; + // VK_KHR_buffer_device_address + PFN_vkGetBufferDeviceAddressKHR GetBufferDeviceAddressKHR; + PFN_vkGetBufferOpaqueCaptureAddressKHR GetBufferOpaqueCaptureAddressKHR; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR GetDeviceMemoryOpaqueCaptureAddressKHR; + // VK_KHR_pipeline_executable_properties PFN_vkGetPipelineExecutablePropertiesKHR GetPipelineExecutablePropertiesKHR; PFN_vkGetPipelineExecutableStatisticsKHR GetPipelineExecutableStatisticsKHR; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index b6fc75c67..43e652c97 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -453,7 +453,8 @@ DeclExt(EXT_line_rasterization); \ DeclExt(GOOGLE_display_timing); \ DeclExt(KHR_timeline_semaphore); \ - DeclExt(KHR_performance_query); + DeclExt(KHR_performance_query); \ + DeclExt(KHR_buffer_device_address); // for simplicity and since the check itself is platform agnostic, // these aren't protected in platform defines @@ -541,7 +542,8 @@ CheckExt(EXT_line_rasterization, VKXX); \ CheckExt(GOOGLE_display_timing, VKXX); \ CheckExt(KHR_timeline_semaphore, VKXX); \ - CheckExt(KHR_performance_query, VKXX); + CheckExt(KHR_performance_query, VKXX); \ + CheckExt(KHR_buffer_device_address, VKXX); #define HookInitVulkanInstanceExts() \ HookInitExtension(KHR_surface, DestroySurfaceKHR); \ @@ -695,6 +697,9 @@ HookInitExtension(KHR_timeline_semaphore, SignalSemaphoreKHR); \ HookInitExtension(KHR_performance_query, AcquireProfilingLockKHR); \ HookInitExtension(KHR_performance_query, ReleaseProfilingLockKHR); \ + HookInitExtension(KHR_buffer_device_address, GetBufferDeviceAddressKHR); \ + HookInitExtension(KHR_buffer_device_address, GetBufferOpaqueCaptureAddressKHR); \ + HookInitExtension(KHR_buffer_device_address, GetDeviceMemoryOpaqueCaptureAddressKHR); \ HookInitDevice_PlatformSpecific() #define DefineHooks() \ @@ -1307,4 +1312,10 @@ HookDefine2(VkResult, vkAcquireProfilingLockKHR, VkDevice, device, \ const VkAcquireProfilingLockInfoKHR *, pInfo); \ HookDefine1(void, vkReleaseProfilingLockKHR, VkDevice, device); \ + HookDefine2(VkDeviceAddress, vkGetBufferDeviceAddressKHR, VkDevice, device, \ + VkBufferDeviceAddressInfoKHR *, pInfo); \ + HookDefine2(uint64_t, vkGetBufferOpaqueCaptureAddressKHR, VkDevice, device, \ + VkBufferDeviceAddressInfoKHR *, pInfo); \ + HookDefine2(uint64_t, vkGetDeviceMemoryOpaqueCaptureAddressKHR, VkDevice, device, \ + VkDeviceMemoryOpaqueCaptureAddressInfoKHR *, pInfo); \ HookDefine_PlatformSpecific() diff --git a/renderdoc/driver/vulkan/vk_info.cpp b/renderdoc/driver/vulkan/vk_info.cpp index 904339c89..65ff352d9 100644 --- a/renderdoc/driver/vulkan/vk_info.cpp +++ b/renderdoc/driver/vulkan/vk_info.cpp @@ -878,14 +878,6 @@ void VulkanCreationInfo::Buffer::Init(VulkanResourceManager *resourceMan, Vulkan { usage = pCreateInfo->usage; size = pCreateInfo->size; - - const VkBufferDeviceAddressCreateInfoEXT *deviceAddress = - (const VkBufferDeviceAddressCreateInfoEXT *)FindNextStruct( - pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT); - if(deviceAddress) - gpuAddress = deviceAddress->deviceAddress; - else - gpuAddress = 0; } void VulkanCreationInfo::BufferView::Init(VulkanResourceManager *resourceMan, diff --git a/renderdoc/driver/vulkan/vk_info.h b/renderdoc/driver/vulkan/vk_info.h index 7c0c06b9b..3de426d32 100644 --- a/renderdoc/driver/vulkan/vk_info.h +++ b/renderdoc/driver/vulkan/vk_info.h @@ -414,7 +414,6 @@ struct VulkanCreationInfo VkBufferUsageFlags usage; uint64_t size; - uint64_t gpuAddress; }; std::map m_Buffer; diff --git a/renderdoc/driver/vulkan/vk_next_chains.cpp b/renderdoc/driver/vulkan/vk_next_chains.cpp index bd87185d2..94a37b71e 100644 --- a/renderdoc/driver/vulkan/vk_next_chains.cpp +++ b/renderdoc/driver/vulkan/vk_next_chains.cpp @@ -83,6 +83,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, VkBufferCreateInfo); \ COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, \ VkBufferDeviceAddressCreateInfoEXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, \ + VkBufferOpaqueCaptureAddressCreateInfoKHR); \ COPY_STRUCT(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, VkCalibratedTimestampInfoEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, VkCommandBufferBeginInfo); \ COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, \ @@ -153,6 +155,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, VkMemoryAllocateInfo); \ COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_BARRIER, VkMemoryBarrier); \ COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VkMemoryDedicatedRequirements); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, \ + VkMemoryOpaqueCaptureAddressAllocateInfoKHR); \ COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, VkMemoryPriorityAllocateInfoEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, VkMemoryRequirements2); \ COPY_STRUCT(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, VkMultisamplePropertiesEXT); \ @@ -164,6 +168,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, VkPhysicalDeviceASTCDecodeFeaturesEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, \ VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, \ + VkPhysicalDeviceBufferDeviceAddressFeaturesKHR); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, \ VkPhysicalDeviceCoherentMemoryFeaturesAMD); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, \ @@ -424,7 +430,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, UnwrapInPlace(out->image), UnwrapInPlace(out->memory)); \ UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, VkBufferMemoryBarrier, \ UnwrapInPlace(out->buffer)); \ - UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, VkBufferDeviceAddressInfoEXT, \ + /* VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT aliased by KHR */ \ + UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, VkBufferDeviceAddressInfoKHR, \ UnwrapInPlace(out->buffer)); \ UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, \ VkBufferMemoryRequirementsInfo2, UnwrapInPlace(out->buffer)); \ @@ -444,6 +451,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, UNWRAP_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, \ VkDescriptorUpdateTemplateCreateInfo, UnwrapInPlace(out->descriptorSetLayout), \ UnwrapInPlace(out->pipelineLayout)); \ + UNWRAP_STRUCT(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, \ + VkDeviceMemoryOpaqueCaptureAddressInfoKHR, UnwrapInPlace(out->memory)); \ UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, VkImageMemoryBarrier, \ UnwrapInPlace(out->image)); \ UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, \ diff --git a/renderdoc/driver/vulkan/vk_serialise.cpp b/renderdoc/driver/vulkan/vk_serialise.cpp index 6d0640f02..fff1e5d70 100644 --- a/renderdoc/driver/vulkan/vk_serialise.cpp +++ b/renderdoc/driver/vulkan/vk_serialise.cpp @@ -446,7 +446,6 @@ SERIALISE_VK_HANDLES(); VkPhysicalDeviceASTCDecodeFeaturesEXT) \ \ /* VK_EXT_buffer_device_address */ \ - PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, VkBufferDeviceAddressInfoEXT) \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, \ VkBufferDeviceAddressCreateInfoEXT) \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, \ @@ -666,6 +665,17 @@ SERIALISE_VK_HANDLES(); PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, VkBindBufferMemoryInfo) \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, VkBindImageMemoryInfo) \ \ + /* VK_KHR_buffer_device_address */ \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, \ + VkPhysicalDeviceBufferDeviceAddressFeaturesKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, VkBufferDeviceAddressInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, \ + VkBufferOpaqueCaptureAddressCreateInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, \ + VkMemoryOpaqueCaptureAddressAllocateInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, \ + VkDeviceMemoryOpaqueCaptureAddressInfoKHR) \ + \ /* VK_KHR_create_renderpass2 */ \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, VkAttachmentDescription2KHR) \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, VkAttachmentReference2KHR) \ @@ -4924,16 +4934,82 @@ void Deserialise(const VkPhysicalDeviceASTCDecodeFeaturesEXT &el) } template -void DoSerialise(SerialiserType &ser, VkBufferDeviceAddressInfoEXT &el) +void DoSerialise(SerialiserType &ser, VkPhysicalDeviceBufferDeviceAddressFeaturesKHR &el) { - RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT); + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(bufferDeviceAddress); + SERIALISE_MEMBER(bufferDeviceAddressCaptureReplay); + SERIALISE_MEMBER(bufferDeviceAddressMultiDevice); +} + +template <> +void Deserialise(const VkPhysicalDeviceBufferDeviceAddressFeaturesKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkBufferDeviceAddressInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR); SerialiseNext(ser, el.sType, el.pNext); SERIALISE_MEMBER(buffer); } template <> -void Deserialise(const VkBufferDeviceAddressInfoEXT &el) +void Deserialise(const VkBufferDeviceAddressInfoKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkBufferOpaqueCaptureAddressCreateInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(opaqueCaptureAddress); +} + +template <> +void Deserialise(const VkBufferOpaqueCaptureAddressCreateInfoKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkMemoryOpaqueCaptureAddressAllocateInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(opaqueCaptureAddress); +} + +template <> +void Deserialise(const VkMemoryOpaqueCaptureAddressAllocateInfoKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkDeviceMemoryOpaqueCaptureAddressInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(memory); +} + +template <> +void Deserialise(const VkDeviceMemoryOpaqueCaptureAddressInfoKHR &el) { DeserialiseNext(el.pNext); } @@ -7536,9 +7612,10 @@ INSTANTIATE_SERIALISE_TYPE(VkBindImagePlaneMemoryInfo); INSTANTIATE_SERIALISE_TYPE(VkBindSparseInfo); INSTANTIATE_SERIALISE_TYPE(VkBufferCreateInfo); INSTANTIATE_SERIALISE_TYPE(VkBufferDeviceAddressCreateInfoEXT); -INSTANTIATE_SERIALISE_TYPE(VkBufferDeviceAddressInfoEXT); +INSTANTIATE_SERIALISE_TYPE(VkBufferDeviceAddressInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryBarrier); INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryRequirementsInfo2); +INSTANTIATE_SERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkBufferViewCreateInfo); INSTANTIATE_SERIALISE_TYPE(VkCalibratedTimestampInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkCommandBufferAllocateInfo); @@ -7579,6 +7656,7 @@ INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupPresentInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupRenderPassBeginInfo); INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupSubmitInfo); INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupSwapchainCreateInfoKHR); +INSTANTIATE_SERIALISE_TYPE(VkDeviceMemoryOpaqueCaptureAddressInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkDeviceQueueCreateInfo); INSTANTIATE_SERIALISE_TYPE(VkDeviceQueueGlobalPriorityCreateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkDeviceQueueInfo2); @@ -7638,14 +7716,16 @@ INSTANTIATE_SERIALISE_TYPE(VkMemoryDedicatedAllocateInfo); INSTANTIATE_SERIALISE_TYPE(VkMemoryDedicatedRequirements); INSTANTIATE_SERIALISE_TYPE(VkMemoryFdPropertiesKHR); INSTANTIATE_SERIALISE_TYPE(VkMemoryGetFdInfoKHR); +INSTANTIATE_SERIALISE_TYPE(VkMemoryOpaqueCaptureAddressAllocateInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkMemoryPriorityAllocateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkMemoryRequirements2); INSTANTIATE_SERIALISE_TYPE(VkMultisamplePropertiesEXT); INSTANTIATE_SERIALISE_TYPE(VkPastPresentationTimingGOOGLE); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDevice16BitStorageFeatures); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDevice8BitStorageFeaturesKHR); -INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceASTCDecodeFeaturesEXT); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceASTCDecodeFeaturesEXT) INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceBufferDeviceAddressFeaturesKHR); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceCoherentMemoryFeaturesAMD); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceConditionalRenderingFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceConservativeRasterizationPropertiesEXT); diff --git a/renderdoc/driver/vulkan/vk_stringise.cpp b/renderdoc/driver/vulkan/vk_stringise.cpp index c7f776adc..ad5b39173 100644 --- a/renderdoc/driver/vulkan/vk_stringise.cpp +++ b/renderdoc/driver/vulkan/vk_stringise.cpp @@ -329,7 +329,7 @@ rdcstr DoStringise(const VkBufferUsageFlagBits &el) STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT); STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT); STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_RAY_TRACING_BIT_NV); - STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR); } END_BITFIELD_STRINGISE(); } @@ -372,7 +372,7 @@ rdcstr DoStringise(const VkBufferCreateFlagBits &el) STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT); STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT); STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_PROTECTED_BIT); - STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR); } END_BITFIELD_STRINGISE(); } @@ -823,6 +823,8 @@ rdcstr DoStringise(const VkMemoryAllocateFlagBits &el) BEGIN_BITFIELD_STRINGISE(VkMemoryAllocateFlagBits); { STRINGISE_BITFIELD_BIT(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT); + STRINGISE_BITFIELD_BIT(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR); + STRINGISE_BITFIELD_BIT(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR); } END_BITFIELD_STRINGISE(); } @@ -1712,7 +1714,6 @@ rdcstr DoStringise(const VkStructureType &el) STRINGISE_ENUM(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR) STRINGISE_ENUM(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR) STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT) - STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT) @@ -1729,6 +1730,11 @@ rdcstr DoStringise(const VkStructureType &el) STRINGISE_ENUM(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR) STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT) STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT) @@ -2047,8 +2053,8 @@ rdcstr DoStringise(const VkResult &el) STRINGISE_ENUM(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT) STRINGISE_ENUM(VK_ERROR_FRAGMENTATION_EXT) STRINGISE_ENUM(VK_ERROR_NOT_PERMITTED_EXT) - STRINGISE_ENUM(VK_ERROR_INVALID_DEVICE_ADDRESS_EXT) STRINGISE_ENUM(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT) + STRINGISE_ENUM(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR) } END_ENUM_STRINGISE(); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index b10ce6f8b..e41c648f0 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -1576,8 +1576,14 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi "geometry/tessellation stages will not be available"); } - if(supportedExtensions.find(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME) != + if(supportedExtensions.find(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME) != supportedExtensions.end()) + { + Extensions.push_back(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME); + RDCLOG("Enabling VK_KHR_buffer_device_address"); + } + else if(supportedExtensions.find(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME) != + supportedExtensions.end()) { Extensions.push_back(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME); RDCLOG("Enabling VK_EXT_buffer_device_address"); @@ -1585,7 +1591,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi else { RDCWARN( - "VK_EXT_buffer_device_address not available, feedback from " + "VK_[KHR|EXT]_buffer_device_address not available, feedback from " "bindless shader access will use less reliable fallback"); } @@ -2187,6 +2193,25 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi } END_PHYS_EXT_CHECK(); + BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceBufferDeviceAddressFeaturesKHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR); + { + CHECK_PHYS_EXT_FEATURE(bufferDeviceAddress); + CHECK_PHYS_EXT_FEATURE(bufferDeviceAddressCaptureReplay); + CHECK_PHYS_EXT_FEATURE(bufferDeviceAddressMultiDevice); + + if(ext->bufferDeviceAddress && !avail.bufferDeviceAddressCaptureReplay) + { + m_FailedReplayStatus = ReplayStatus::APIHardwareUnsupported; + RDCERR( + "Capture requires bufferDeviceAddress support, which is available, but " + "bufferDeviceAddressCaptureReplay support is not available which is required to " + "replay"); + return false; + } + } + END_PHYS_EXT_CHECK(); + BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT); { @@ -3008,16 +3033,20 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, fragmentDensityMapFeatures->fragmentDensityMapNonSubsampledImages = true; } - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *bufferAddressFeatures = + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *bufferAddressFeaturesEXT = (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)FindNextStruct( &createInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT); + VkPhysicalDeviceBufferDeviceAddressFeaturesKHR *bufferAddressFeaturesKHR = + (VkPhysicalDeviceBufferDeviceAddressFeaturesKHR *)FindNextStruct( + &createInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR); - if(bufferAddressFeatures) - { - // we must turn on bufferDeviceAddressCaptureReplay. We verified that this feature was available - // before we whitelisted the extension - bufferAddressFeatures->bufferDeviceAddressCaptureReplay = VK_TRUE; - } + // we must turn on bufferDeviceAddressCaptureReplay. We verified that this feature was available + // before we whitelisted the extension + if(bufferAddressFeaturesKHR) + bufferAddressFeaturesKHR->bufferDeviceAddressCaptureReplay = VK_TRUE; + + if(bufferAddressFeaturesEXT) + bufferAddressFeaturesEXT->bufferDeviceAddressCaptureReplay = VK_TRUE; VkResult ret; SERIALISE_TIME_CALL(ret = createFunc(Unwrap(physicalDevice), &createInfo, pAllocator, pDevice)); diff --git a/renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp index a55325f68..6ae66b09c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp @@ -759,4 +759,28 @@ VkResult WrappedVulkan::vkGetPipelineExecutableInternalRepresentationsKHR( unwrappedInfo.pipeline = Unwrap(unwrappedInfo.pipeline); return ObjDisp(device)->GetPipelineExecutableInternalRepresentationsKHR( Unwrap(device), &unwrappedInfo, pInternalRepresentationCount, pInternalRepresentations); +} + +VkDeviceAddress WrappedVulkan::vkGetBufferDeviceAddressKHR(VkDevice device, + VkBufferDeviceAddressInfoKHR *pInfo) +{ + VkBufferDeviceAddressInfoKHR unwrappedInfo = *pInfo; + unwrappedInfo.buffer = Unwrap(unwrappedInfo.buffer); + return ObjDisp(device)->GetBufferDeviceAddressKHR(Unwrap(device), &unwrappedInfo); +} + +uint64_t WrappedVulkan::vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, + VkBufferDeviceAddressInfoKHR *pInfo) +{ + VkBufferDeviceAddressInfoKHR unwrappedInfo = *pInfo; + unwrappedInfo.buffer = Unwrap(unwrappedInfo.buffer); + return ObjDisp(device)->GetBufferOpaqueCaptureAddressKHR(Unwrap(device), &unwrappedInfo); +} + +uint64_t WrappedVulkan::vkGetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfoKHR *pInfo) +{ + VkDeviceMemoryOpaqueCaptureAddressInfoKHR unwrappedInfo = *pInfo; + unwrappedInfo.memory = Unwrap(unwrappedInfo.memory); + return ObjDisp(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(Unwrap(device), &unwrappedInfo); } \ No newline at end of file diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index 3cafbc858..e82106d10 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -395,6 +395,16 @@ VkResult WrappedVulkan::vkAllocateMemory(VkDevice device, const VkMemoryAllocate UnwrapNextChain(m_State, "VkMemoryAllocateInfo", tempMem, (VkBaseInStructure *)&unwrapped); + VkMemoryAllocateFlagsInfo *memFlags = (VkMemoryAllocateFlagsInfo *)FindNextStruct( + &unwrapped, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO); + + // since the application must specify VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR itself, we can + // assume the struct is present and just add the capture-replay flag to allow us to specify the + // address on replay. We ensured the physical device can support this feature (and it was enabled) + // when whitelisting the extension and creating the device. + if(memFlags && (memFlags->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR)) + memFlags->flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; + VkResult ret; SERIALISE_TIME_CALL( ret = ObjDisp(device)->AllocateMemory(Unwrap(device), &unwrapped, pAllocator, pMemory)); @@ -411,19 +421,47 @@ VkResult WrappedVulkan::vkAllocateMemory(VkDevice device, const VkMemoryAllocate { Chunk *chunk = NULL; - { - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CHUNK(VulkanChunk::vkAllocateMemory); - Serialise_vkAllocateMemory(ser, device, &info, NULL, pMemory); - - chunk = scope.Get(); - } + VkMemoryAllocateInfo serialisedInfo = info; + VkMemoryOpaqueCaptureAddressAllocateInfoKHR memoryDeviceAddress = { + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, + }; // create resource record for gpu memory VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pMemory); RDCASSERT(record); + memFlags = (VkMemoryAllocateFlagsInfo *)FindNextStruct( + &serialisedInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO); + + if(memFlags && (memFlags->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR)) + { + VkDeviceMemoryOpaqueCaptureAddressInfoKHR getInfo = { + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, NULL, Unwrap(*pMemory), + }; + + memoryDeviceAddress.opaqueCaptureAddress = + ObjDisp(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(Unwrap(device), &getInfo); + + // we explicitly DON'T assert on this, because some drivers will only need the device + // address specified at allocate time. + // RDCASSERT(memoryDeviceAddress.opaqueCaptureAddress); + + // push this struct onto the start of the chain + memoryDeviceAddress.pNext = serialisedInfo.pNext; + serialisedInfo.pNext = &memoryDeviceAddress; + + memFlags->flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; + } + + { + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkAllocateMemory); + Serialise_vkAllocateMemory(ser, device, &serialisedInfo, NULL, pMemory); + + chunk = scope.Get(); + } + record->AddChunk(chunk); record->Length = info.allocationSize; @@ -1115,8 +1153,8 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo // If we're using this buffer for device addresses, ensure we force on capture replay bit. // We ensured the physical device can support this feature before whitelisting the extension. - if(adjusted_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) - adjusted_info.flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT; + if(adjusted_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR) + adjusted_info.flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; byte *tempMem = GetTempMemory(GetNextPatchSize(adjusted_info.pNext)); @@ -1135,34 +1173,56 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo Chunk *chunk = NULL; VkBufferCreateInfo serialisedCreateInfo = *pCreateInfo; - VkBufferDeviceAddressCreateInfoEXT bufferDeviceAddress = { + VkBufferDeviceAddressCreateInfoEXT bufferDeviceAddressEXT = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, }; + VkBufferOpaqueCaptureAddressCreateInfoKHR bufferDeviceAddressKHR = { + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, + }; VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pBuffer); record->memSize = pCreateInfo->size; - // if we're using VK_EXT_buffer_device_address, we fetch the device address that's been + // if we're using VK_[KHR|EXT]_buffer_device_address, we fetch the device address that's been // allocated and insert it into the next chain and patch the flags so that it replays // naturally. - if(GetRecord(device)->instDevInfo->ext_EXT_buffer_device_address && - (pCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0) + if((pCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR) != 0) { - VkBufferDeviceAddressInfoEXT getInfo = { - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, NULL, Unwrap(*pBuffer), + VkBufferDeviceAddressInfoKHR getInfo = { + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, NULL, Unwrap(*pBuffer), }; - bufferDeviceAddress.deviceAddress = - ObjDisp(device)->GetBufferDeviceAddressEXT(Unwrap(device), &getInfo); + if(GetExtensions(GetRecord(device)).ext_KHR_buffer_device_address) + { + bufferDeviceAddressKHR.opaqueCaptureAddress = + ObjDisp(device)->GetBufferOpaqueCaptureAddressKHR(Unwrap(device), &getInfo); - RDCASSERT(bufferDeviceAddress.deviceAddress); + // we explicitly DON'T assert on this, because some drivers will only need the device + // address specified at allocate time. + // RDCASSERT(bufferDeviceAddressKHR.opaqueCaptureAddress); - // push this struct onto the start of the chain - bufferDeviceAddress.pNext = serialisedCreateInfo.pNext; - serialisedCreateInfo.pNext = &bufferDeviceAddress; + // push this struct onto the start of the chain + bufferDeviceAddressKHR.pNext = serialisedCreateInfo.pNext; + serialisedCreateInfo.pNext = &bufferDeviceAddressKHR; + } + else if(GetExtensions(GetRecord(device)).ext_EXT_buffer_device_address) + { + bufferDeviceAddressEXT.deviceAddress = + ObjDisp(device)->GetBufferDeviceAddressEXT(Unwrap(device), &getInfo); - // tell the driver we're giving it a pre-allocated address to use - serialisedCreateInfo.flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT; + RDCASSERT(bufferDeviceAddressEXT.deviceAddress); + + // push this struct onto the start of the chain + bufferDeviceAddressEXT.pNext = serialisedCreateInfo.pNext; + serialisedCreateInfo.pNext = &bufferDeviceAddressEXT; + } + else + { + RDCERR("Device address bit specified but no device address extension enabled"); + } + + // tell the driver on replay that we're giving it a pre-allocated address to use + serialisedCreateInfo.flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; // this buffer must be forced to be in any captures, since we can't track when it's used by // address diff --git a/util/test/demos/3rdparty/volk/README.md b/util/test/demos/3rdparty/volk/README.md index 68da0685f..bb5bb9b41 100644 --- a/util/test/demos/3rdparty/volk/README.md +++ b/util/test/demos/3rdparty/volk/README.md @@ -1 +1 @@ -volk from https://github.com/zeux/volk at commit 4cdddd9b251151a1e84cfcabc183f741ada1a358 +volk from https://github.com/zeux/volk at commit b1128a0df781cb41f47342925177fdf5b8d112bd diff --git a/util/test/demos/3rdparty/volk/volk.c b/util/test/demos/3rdparty/volk/volk.c index ce39b1687..c93a3eda0 100644 --- a/util/test/demos/3rdparty/volk/volk.c +++ b/util/test/demos/3rdparty/volk/volk.c @@ -50,7 +50,7 @@ VkResult volkInitialize(void) #elif defined(__APPLE__) void* module = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); if (!module) - module = dlopen("libvulkan.dylib.1", RTLD_NOW | RTLD_LOCAL); + module = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); if (!module) module = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL); if (!module) @@ -167,8 +167,16 @@ static void volkGenLoadInstance(void* context, PFN_vkVoidFunction (*load)(void*, vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)load(context, "vkDestroyDebugReportCallbackEXT"); #endif /* defined(VK_EXT_debug_report) */ #if defined(VK_EXT_debug_utils) + vkCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)load(context, "vkCmdBeginDebugUtilsLabelEXT"); + vkCmdEndDebugUtilsLabelEXT = (PFN_vkCmdEndDebugUtilsLabelEXT)load(context, "vkCmdEndDebugUtilsLabelEXT"); + vkCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)load(context, "vkCmdInsertDebugUtilsLabelEXT"); vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)load(context, "vkCreateDebugUtilsMessengerEXT"); vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)load(context, "vkDestroyDebugUtilsMessengerEXT"); + vkQueueBeginDebugUtilsLabelEXT = (PFN_vkQueueBeginDebugUtilsLabelEXT)load(context, "vkQueueBeginDebugUtilsLabelEXT"); + vkQueueEndDebugUtilsLabelEXT = (PFN_vkQueueEndDebugUtilsLabelEXT)load(context, "vkQueueEndDebugUtilsLabelEXT"); + vkQueueInsertDebugUtilsLabelEXT = (PFN_vkQueueInsertDebugUtilsLabelEXT)load(context, "vkQueueInsertDebugUtilsLabelEXT"); + vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)load(context, "vkSetDebugUtilsObjectNameEXT"); + vkSetDebugUtilsObjectTagEXT = (PFN_vkSetDebugUtilsObjectTagEXT)load(context, "vkSetDebugUtilsObjectTagEXT"); vkSubmitDebugUtilsMessageEXT = (PFN_vkSubmitDebugUtilsMessageEXT)load(context, "vkSubmitDebugUtilsMessageEXT"); #endif /* defined(VK_EXT_debug_utils) */ #if defined(VK_EXT_direct_mode_display) @@ -238,6 +246,10 @@ static void volkGenLoadInstance(void* context, PFN_vkVoidFunction (*load)(void*, vkGetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)load(context, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"); vkGetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)load(context, "vkGetPhysicalDeviceSurfaceFormats2KHR"); #endif /* defined(VK_KHR_get_surface_capabilities2) */ +#if defined(VK_KHR_performance_query) + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)load(context, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)load(context, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"); +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_surface) vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)load(context, "vkDestroySurfaceKHR"); vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)load(context, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); @@ -465,16 +477,6 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)load(context, "vkDebugMarkerSetObjectNameEXT"); vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)load(context, "vkDebugMarkerSetObjectTagEXT"); #endif /* defined(VK_EXT_debug_marker) */ -#if defined(VK_EXT_debug_utils) - vkCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)load(context, "vkCmdBeginDebugUtilsLabelEXT"); - vkCmdEndDebugUtilsLabelEXT = (PFN_vkCmdEndDebugUtilsLabelEXT)load(context, "vkCmdEndDebugUtilsLabelEXT"); - vkCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)load(context, "vkCmdInsertDebugUtilsLabelEXT"); - vkQueueBeginDebugUtilsLabelEXT = (PFN_vkQueueBeginDebugUtilsLabelEXT)load(context, "vkQueueBeginDebugUtilsLabelEXT"); - vkQueueEndDebugUtilsLabelEXT = (PFN_vkQueueEndDebugUtilsLabelEXT)load(context, "vkQueueEndDebugUtilsLabelEXT"); - vkQueueInsertDebugUtilsLabelEXT = (PFN_vkQueueInsertDebugUtilsLabelEXT)load(context, "vkQueueInsertDebugUtilsLabelEXT"); - vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)load(context, "vkSetDebugUtilsObjectNameEXT"); - vkSetDebugUtilsObjectTagEXT = (PFN_vkSetDebugUtilsObjectTagEXT)load(context, "vkSetDebugUtilsObjectTagEXT"); -#endif /* defined(VK_EXT_debug_utils) */ #if defined(VK_EXT_discard_rectangles) vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)load(context, "vkCmdSetDiscardRectangleEXT"); #endif /* defined(VK_EXT_discard_rectangles) */ @@ -539,6 +541,11 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2KHR)load(context, "vkBindBufferMemory2KHR"); vkBindImageMemory2KHR = (PFN_vkBindImageMemory2KHR)load(context, "vkBindImageMemory2KHR"); #endif /* defined(VK_KHR_bind_memory2) */ +#if defined(VK_KHR_buffer_device_address) + vkGetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)load(context, "vkGetBufferDeviceAddressKHR"); + vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR"); + vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); +#endif /* defined(VK_KHR_buffer_device_address) */ #if defined(VK_KHR_create_renderpass2) vkCmdBeginRenderPass2KHR = (PFN_vkCmdBeginRenderPass2KHR)load(context, "vkCmdBeginRenderPass2KHR"); vkCmdEndRenderPass2KHR = (PFN_vkCmdEndRenderPass2KHR)load(context, "vkCmdEndRenderPass2KHR"); @@ -597,6 +604,10 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c #if defined(VK_KHR_maintenance3) vkGetDescriptorSetLayoutSupportKHR = (PFN_vkGetDescriptorSetLayoutSupportKHR)load(context, "vkGetDescriptorSetLayoutSupportKHR"); #endif /* defined(VK_KHR_maintenance3) */ +#if defined(VK_KHR_performance_query) + vkAcquireProfilingLockKHR = (PFN_vkAcquireProfilingLockKHR)load(context, "vkAcquireProfilingLockKHR"); + vkReleaseProfilingLockKHR = (PFN_vkReleaseProfilingLockKHR)load(context, "vkReleaseProfilingLockKHR"); +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_pipeline_executable_properties) vkGetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)load(context, "vkGetPipelineExecutableInternalRepresentationsKHR"); vkGetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)load(context, "vkGetPipelineExecutablePropertiesKHR"); @@ -619,6 +630,11 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)load(context, "vkGetSwapchainImagesKHR"); vkQueuePresentKHR = (PFN_vkQueuePresentKHR)load(context, "vkQueuePresentKHR"); #endif /* defined(VK_KHR_swapchain) */ +#if defined(VK_KHR_timeline_semaphore) + vkGetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)load(context, "vkGetSemaphoreCounterValueKHR"); + vkSignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)load(context, "vkSignalSemaphoreKHR"); + vkWaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)load(context, "vkWaitSemaphoresKHR"); +#endif /* defined(VK_KHR_timeline_semaphore) */ #if defined(VK_NVX_device_generated_commands) vkCmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)load(context, "vkCmdProcessCommandsNVX"); vkCmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)load(context, "vkCmdReserveSpaceForCommandsNVX"); @@ -862,16 +878,6 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, table->vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)load(context, "vkDebugMarkerSetObjectNameEXT"); table->vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)load(context, "vkDebugMarkerSetObjectTagEXT"); #endif /* defined(VK_EXT_debug_marker) */ -#if defined(VK_EXT_debug_utils) - table->vkCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)load(context, "vkCmdBeginDebugUtilsLabelEXT"); - table->vkCmdEndDebugUtilsLabelEXT = (PFN_vkCmdEndDebugUtilsLabelEXT)load(context, "vkCmdEndDebugUtilsLabelEXT"); - table->vkCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)load(context, "vkCmdInsertDebugUtilsLabelEXT"); - table->vkQueueBeginDebugUtilsLabelEXT = (PFN_vkQueueBeginDebugUtilsLabelEXT)load(context, "vkQueueBeginDebugUtilsLabelEXT"); - table->vkQueueEndDebugUtilsLabelEXT = (PFN_vkQueueEndDebugUtilsLabelEXT)load(context, "vkQueueEndDebugUtilsLabelEXT"); - table->vkQueueInsertDebugUtilsLabelEXT = (PFN_vkQueueInsertDebugUtilsLabelEXT)load(context, "vkQueueInsertDebugUtilsLabelEXT"); - table->vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)load(context, "vkSetDebugUtilsObjectNameEXT"); - table->vkSetDebugUtilsObjectTagEXT = (PFN_vkSetDebugUtilsObjectTagEXT)load(context, "vkSetDebugUtilsObjectTagEXT"); -#endif /* defined(VK_EXT_debug_utils) */ #if defined(VK_EXT_discard_rectangles) table->vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)load(context, "vkCmdSetDiscardRectangleEXT"); #endif /* defined(VK_EXT_discard_rectangles) */ @@ -936,6 +942,11 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, table->vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2KHR)load(context, "vkBindBufferMemory2KHR"); table->vkBindImageMemory2KHR = (PFN_vkBindImageMemory2KHR)load(context, "vkBindImageMemory2KHR"); #endif /* defined(VK_KHR_bind_memory2) */ +#if defined(VK_KHR_buffer_device_address) + table->vkGetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)load(context, "vkGetBufferDeviceAddressKHR"); + table->vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR"); + table->vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); +#endif /* defined(VK_KHR_buffer_device_address) */ #if defined(VK_KHR_create_renderpass2) table->vkCmdBeginRenderPass2KHR = (PFN_vkCmdBeginRenderPass2KHR)load(context, "vkCmdBeginRenderPass2KHR"); table->vkCmdEndRenderPass2KHR = (PFN_vkCmdEndRenderPass2KHR)load(context, "vkCmdEndRenderPass2KHR"); @@ -994,6 +1005,10 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, #if defined(VK_KHR_maintenance3) table->vkGetDescriptorSetLayoutSupportKHR = (PFN_vkGetDescriptorSetLayoutSupportKHR)load(context, "vkGetDescriptorSetLayoutSupportKHR"); #endif /* defined(VK_KHR_maintenance3) */ +#if defined(VK_KHR_performance_query) + table->vkAcquireProfilingLockKHR = (PFN_vkAcquireProfilingLockKHR)load(context, "vkAcquireProfilingLockKHR"); + table->vkReleaseProfilingLockKHR = (PFN_vkReleaseProfilingLockKHR)load(context, "vkReleaseProfilingLockKHR"); +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_pipeline_executable_properties) table->vkGetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)load(context, "vkGetPipelineExecutableInternalRepresentationsKHR"); table->vkGetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)load(context, "vkGetPipelineExecutablePropertiesKHR"); @@ -1016,6 +1031,11 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, table->vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)load(context, "vkGetSwapchainImagesKHR"); table->vkQueuePresentKHR = (PFN_vkQueuePresentKHR)load(context, "vkQueuePresentKHR"); #endif /* defined(VK_KHR_swapchain) */ +#if defined(VK_KHR_timeline_semaphore) + table->vkGetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)load(context, "vkGetSemaphoreCounterValueKHR"); + table->vkSignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)load(context, "vkSignalSemaphoreKHR"); + table->vkWaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)load(context, "vkWaitSemaphoresKHR"); +#endif /* defined(VK_KHR_timeline_semaphore) */ #if defined(VK_NVX_device_generated_commands) table->vkCmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)load(context, "vkCmdProcessCommandsNVX"); table->vkCmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)load(context, "vkCmdReserveSpaceForCommandsNVX"); @@ -1400,6 +1420,11 @@ PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; #endif /* defined(VK_KHR_bind_memory2) */ +#if defined(VK_KHR_buffer_device_address) +PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; +PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; +PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; +#endif /* defined(VK_KHR_buffer_device_address) */ #if defined(VK_KHR_create_renderpass2) PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; @@ -1498,6 +1523,12 @@ PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; #if defined(VK_KHR_maintenance3) PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; #endif /* defined(VK_KHR_maintenance3) */ +#if defined(VK_KHR_performance_query) +PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; +PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; +PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; +PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_pipeline_executable_properties) PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; @@ -1527,6 +1558,11 @@ PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; PFN_vkQueuePresentKHR vkQueuePresentKHR; #endif /* defined(VK_KHR_swapchain) */ +#if defined(VK_KHR_timeline_semaphore) +PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; +PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; +PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; +#endif /* defined(VK_KHR_timeline_semaphore) */ #if defined(VK_KHR_wayland_surface) PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; diff --git a/util/test/demos/3rdparty/volk/volk.h b/util/test/demos/3rdparty/volk/volk.h index 410e8494a..7944a02d1 100644 --- a/util/test/demos/3rdparty/volk/volk.h +++ b/util/test/demos/3rdparty/volk/volk.h @@ -13,16 +13,18 @@ # error To use volk, you need to define VK_NO_PROTOTYPES before including vulkan.h #endif -/* VOLK_GENERATE_VERSION */ -#define VOLK_HEADER_VERSION 119 -/* VOLK_GENERATE_VERSION */ +/* VOLK_GENERATE_VERSION_DEFINE */ +#define VOLK_HEADER_VERSION 129 +/* VOLK_GENERATE_VERSION_DEFINE */ #ifndef VK_NO_PROTOTYPES # define VK_NO_PROTOTYPES #endif #ifndef VULKAN_H_ -# ifdef VK_USE_PLATFORM_WIN32_KHR +# ifdef VOLK_VULKAN_H_PATH +# include VOLK_VULKAN_H_PATH +# elif defined(VK_USE_PLATFORM_WIN32_KHR) # include # include @@ -271,16 +273,6 @@ struct VolkDeviceTable PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; #endif /* defined(VK_EXT_debug_marker) */ -#if defined(VK_EXT_debug_utils) - PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT; - PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT; - PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT; - PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT; - PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT; - PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT; - PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT; - PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT; -#endif /* defined(VK_EXT_debug_utils) */ #if defined(VK_EXT_discard_rectangles) PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; #endif /* defined(VK_EXT_discard_rectangles) */ @@ -345,6 +337,11 @@ struct VolkDeviceTable PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; #endif /* defined(VK_KHR_bind_memory2) */ +#if defined(VK_KHR_buffer_device_address) + PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; + PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; +#endif /* defined(VK_KHR_buffer_device_address) */ #if defined(VK_KHR_create_renderpass2) PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; @@ -403,6 +400,10 @@ struct VolkDeviceTable #if defined(VK_KHR_maintenance3) PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; #endif /* defined(VK_KHR_maintenance3) */ +#if defined(VK_KHR_performance_query) + PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; + PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_pipeline_executable_properties) PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; @@ -425,6 +426,11 @@ struct VolkDeviceTable PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; PFN_vkQueuePresentKHR vkQueuePresentKHR; #endif /* defined(VK_KHR_swapchain) */ +#if defined(VK_KHR_timeline_semaphore) + PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; + PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; + PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; +#endif /* defined(VK_KHR_timeline_semaphore) */ #if defined(VK_NVX_device_generated_commands) PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX; PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX; @@ -805,6 +811,11 @@ extern PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; extern PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; extern PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; #endif /* defined(VK_KHR_bind_memory2) */ +#if defined(VK_KHR_buffer_device_address) +extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; +extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; +extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; +#endif /* defined(VK_KHR_buffer_device_address) */ #if defined(VK_KHR_create_renderpass2) extern PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; extern PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; @@ -903,6 +914,12 @@ extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; #if defined(VK_KHR_maintenance3) extern PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; #endif /* defined(VK_KHR_maintenance3) */ +#if defined(VK_KHR_performance_query) +extern PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; +extern PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; +extern PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; +extern PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; +#endif /* defined(VK_KHR_performance_query) */ #if defined(VK_KHR_pipeline_executable_properties) extern PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; extern PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; @@ -932,6 +949,11 @@ extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; extern PFN_vkQueuePresentKHR vkQueuePresentKHR; #endif /* defined(VK_KHR_swapchain) */ +#if defined(VK_KHR_timeline_semaphore) +extern PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; +extern PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; +extern PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; +#endif /* defined(VK_KHR_timeline_semaphore) */ #if defined(VK_KHR_wayland_surface) extern PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; extern PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; @@ -1039,6 +1061,14 @@ extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; #endif +#ifdef VOLK_IMPLEMENTATION +#undef VOLK_IMPLEMENTATION +// Prevent tools like dependency checkers that don't evaluate +// macros from detecting a cyclic dependency. +#define VOLK_SOURCE "volk.c" +#include VOLK_SOURCE +#endif + /** * Copyright (c) 2018-2019 Arseny Kapoulkine * diff --git a/util/test/demos/CMakeLists.txt b/util/test/demos/CMakeLists.txt index 0f0741c0c..f6723c280 100644 --- a/util/test/demos/CMakeLists.txt +++ b/util/test/demos/CMakeLists.txt @@ -7,15 +7,16 @@ set(VULKAN_SRC vk/vk_helpers.cpp vk/vk_test.cpp vk/vk_adv_cbuffer_zoo.cpp - vk/vk_buffer_address.cpp vk/vk_cbuffer_zoo.cpp vk/vk_descriptor_index.cpp vk/vk_discard_rects.cpp vk/vk_draw_zoo.cpp + vk/vk_ext_buffer_address.cpp vk/vk_image_layouts.cpp vk/vk_imageless_framebuffer.cpp vk/vk_indirect.cpp vk/vk_int8_ibuffer.cpp + vk/vk_khr_buffer_address.cpp vk/vk_line_raster.cpp vk/vk_misaligned_dirty.cpp vk/vk_multi_thread_windows.cpp diff --git a/util/test/demos/demos.vcxproj b/util/test/demos/demos.vcxproj index afbe8f5b2..7b4f91379 100644 --- a/util/test/demos/demos.vcxproj +++ b/util/test/demos/demos.vcxproj @@ -216,6 +216,7 @@ + @@ -229,7 +230,7 @@ - + diff --git a/util/test/demos/demos.vcxproj.filters b/util/test/demos/demos.vcxproj.filters index 1fee3ebb7..cde4c2382 100644 --- a/util/test/demos/demos.vcxproj.filters +++ b/util/test/demos/demos.vcxproj.filters @@ -246,9 +246,6 @@ Vulkan\demos - - Vulkan\demos - Vulkan\demos @@ -361,6 +358,12 @@ Vulkan\demos + + Vulkan\demos + + + Vulkan\demos + diff --git a/util/test/demos/vk/official/vulkan/vulkan_core.h b/util/test/demos/vk/official/vulkan/vulkan_core.h index 888674e72..f41ccf4a4 100644 --- a/util/test/demos/vk/official/vulkan/vulkan_core.h +++ b/util/test/demos/vk/official/vulkan/vulkan_core.h @@ -44,7 +44,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 120 +#define VK_HEADER_VERSION 129 #define VK_NULL_HANDLE 0 @@ -145,10 +145,11 @@ typedef enum VkResult { VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, VK_ERROR_FRAGMENTATION_EXT = -1000161000, VK_ERROR_NOT_PERMITTED_EXT = -1000174001, - VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, VK_RESULT_END_RANGE = VK_INCOMPLETE, VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), @@ -370,6 +371,13 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, @@ -443,11 +451,13 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = 1000175000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, @@ -470,6 +480,12 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = 1000207005, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000, VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, @@ -491,13 +507,16 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000, VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, @@ -514,6 +533,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, @@ -594,6 +618,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -939,6 +964,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, VK_QUERY_TYPE_TIMESTAMP = 2, VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, @@ -972,6 +998,10 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000241003, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, @@ -1241,6 +1271,7 @@ typedef enum VkSamplerAddressMode { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), @@ -1507,6 +1538,8 @@ typedef enum VkMemoryPropertyFlagBits { VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkMemoryPropertyFlagBits; typedef VkFlags VkMemoryPropertyFlags; @@ -1630,7 +1663,8 @@ typedef enum VkBufferCreateFlagBits { VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferCreateFlagBits; typedef VkFlags VkBufferCreateFlags; @@ -1649,7 +1683,8 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferUsageFlagBits; typedef VkFlags VkBufferUsageFlags; @@ -1672,10 +1707,11 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, + VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -4032,6 +4068,8 @@ typedef VkFlags VkPeerMemoryFeatureFlags; typedef enum VkMemoryAllocateFlagBits { VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004, VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkMemoryAllocateFlagBits; @@ -5081,7 +5119,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( #define VK_KHR_display 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) -#define VK_KHR_DISPLAY_SPEC_VERSION 21 +#define VK_KHR_DISPLAY_SPEC_VERSION 23 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" typedef enum VkDisplayPlaneAlphaFlagBitsKHR { @@ -5204,7 +5242,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( #define VK_KHR_display_swapchain 1 -#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" typedef struct VkDisplayPresentInfoKHR { VkStructureType sType; @@ -5227,7 +5265,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( #define VK_KHR_sampler_mirror_clamp_to_edge 1 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" @@ -5243,7 +5281,7 @@ typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesK #define VK_KHR_get_physical_device_properties2 1 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; @@ -5308,7 +5346,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( #define VK_KHR_device_group 1 -#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 +#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; @@ -5896,6 +5934,150 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( #endif +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, + VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR, + VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1), + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_QUERY_SCOPE_RENDER_PASS_KHR = 1, + VK_QUERY_SCOPE_COMMAND_KHR = 2, + VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1), + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, + VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR, + VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1), + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002, + VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterDescriptionFlagBitsKHR; +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +typedef enum VkAcquireProfilingLockFlagBitsKHR { + VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAcquireProfilingLockFlagBitsKHR; +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + const void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + const void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif + + #define VK_KHR_maintenance2 1 #define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" @@ -6093,7 +6275,7 @@ typedef struct VkImageFormatListCreateInfoKHR { #define VK_KHR_sampler_ycbcr_conversion 1 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; @@ -6197,6 +6379,17 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( #endif +#define VK_KHR_shader_subgroup_extended_types 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types" +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + + + #define VK_KHR_8bit_storage 1 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" @@ -6222,6 +6415,18 @@ typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { +#define VK_KHR_shader_clock 1 +#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 +#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + #define VK_KHR_driver_properties 1 #define VK_MAX_DRIVER_NAME_SIZE_KHR 256 #define VK_MAX_DRIVER_INFO_SIZE_KHR 256 @@ -6338,6 +6543,89 @@ typedef struct VkPhysicalDeviceDepthStencilResolvePropertiesKHR { #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" +#define VK_KHR_timeline_semaphore 1 +#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2 +#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore" + +typedef enum VkSemaphoreTypeKHR { + VK_SEMAPHORE_TYPE_BINARY_KHR = 0, + VK_SEMAPHORE_TYPE_TIMELINE_KHR = 1, + VK_SEMAPHORE_TYPE_BEGIN_RANGE_KHR = VK_SEMAPHORE_TYPE_BINARY_KHR, + VK_SEMAPHORE_TYPE_END_RANGE_KHR = VK_SEMAPHORE_TYPE_TIMELINE_KHR, + VK_SEMAPHORE_TYPE_RANGE_SIZE_KHR = (VK_SEMAPHORE_TYPE_TIMELINE_KHR - VK_SEMAPHORE_TYPE_BINARY_KHR + 1), + VK_SEMAPHORE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSemaphoreTypeKHR; + +typedef enum VkSemaphoreWaitFlagBitsKHR { + VK_SEMAPHORE_WAIT_ANY_BIT_KHR = 0x00000001, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSemaphoreWaitFlagBitsKHR; +typedef VkFlags VkSemaphoreWaitFlagsKHR; +typedef struct VkPhysicalDeviceTimelineSemaphoreFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; + +typedef struct VkPhysicalDeviceTimelineSemaphorePropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphorePropertiesKHR; + +typedef struct VkSemaphoreTypeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphoreTypeKHR semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfoKHR; + +typedef struct VkTimelineSemaphoreSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfoKHR; + +typedef struct VkSemaphoreWaitInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphoreWaitFlagsKHR flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfoKHR; + +typedef struct VkSemaphoreSignalInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfoKHR* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfoKHR* pSignalInfo); +#endif + + #define VK_KHR_vulkan_memory_model 1 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" @@ -6351,6 +6639,11 @@ typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { +#define VK_KHR_spirv_1_4 1 +#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 +#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" + + #define VK_KHR_surface_protected_capabilities 1 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities" @@ -6362,6 +6655,30 @@ typedef struct VkSurfaceProtectedCapabilitiesKHR { +#define VK_KHR_separate_depth_stencil_layouts 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts" +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + +typedef struct VkAttachmentReferenceStencilLayoutKHR { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayoutKHR; + +typedef struct VkAttachmentDescriptionStencilLayoutKHR { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayoutKHR; + + + #define VK_KHR_uniform_buffer_standard_layout 1 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout" @@ -6373,6 +6690,61 @@ typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { +#define VK_KHR_buffer_device_address 1 +typedef uint64_t VkDeviceAddress; +#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; + +typedef struct VkBufferDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfoKHR; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfoKHR; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfoKHR; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfoKHR; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfoKHR* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfoKHR* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo); +#endif + + #define VK_KHR_pipeline_executable_properties 1 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" @@ -6812,7 +7184,7 @@ VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( #define VK_AMD_draw_indirect_count 1 -#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); @@ -6989,7 +7361,7 @@ typedef struct VkExportMemoryAllocateInfoNV { #define VK_EXT_validation_flags 1 -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" typedef enum VkValidationCheckEXT { @@ -7024,7 +7396,7 @@ typedef struct VkValidationFlagsEXT { #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { VkStructureType sType; - const void* pNext; + void* pNext; VkBool32 textureCompressionASTC_HDR; } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; @@ -7048,7 +7420,7 @@ typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { #define VK_EXT_conditional_rendering 1 -#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1 +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" typedef enum VkConditionalRenderingFlagBitsEXT { @@ -7680,7 +8052,7 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { #define VK_EXT_hdr_metadata 1 -#define VK_EXT_HDR_METADATA_SPEC_VERSION 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" typedef struct VkXYColorEXT { float x; @@ -7864,7 +8236,7 @@ VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( #define VK_EXT_sampler_filter_minmax 1 -#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" typedef enum VkSamplerReductionModeEXT { @@ -8742,7 +9114,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( #define VK_NV_representative_fragment_test 1 -#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { VkStructureType sType; @@ -8901,7 +9273,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( #define VK_AMD_shader_core_properties 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { VkStructureType sType; @@ -9091,7 +9463,7 @@ typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { #define VK_NV_shader_image_footprint 1 -#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { VkStructureType sType; @@ -9452,6 +9824,17 @@ typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { +#define VK_AMD_device_coherent_memory 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" +typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 deviceCoherentMemory; +} VkPhysicalDeviceCoherentMemoryFeaturesAMD; + + + #define VK_EXT_memory_budget 1 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" @@ -9493,7 +9876,6 @@ typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { #define VK_EXT_buffer_device_address 1 -typedef uint64_t VkDeviceAddress; #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { @@ -9506,11 +9888,7 @@ typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; -typedef struct VkBufferDeviceAddressInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfoEXT; +typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT; typedef struct VkBufferDeviceAddressCreateInfoEXT { VkStructureType sType; @@ -9518,12 +9896,12 @@ typedef struct VkBufferDeviceAddressCreateInfoEXT { VkDeviceAddress deviceAddress; } VkBufferDeviceAddressCreateInfoEXT; -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( VkDevice device, - const VkBufferDeviceAddressInfoEXT* pInfo); + const VkBufferDeviceAddressInfoKHR* pInfo); #endif @@ -9714,7 +10092,7 @@ typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { #define VK_EXT_headless_surface 1 -#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 0 +#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; typedef struct VkHeadlessSurfaceCreateInfoEXT { @@ -9845,6 +10223,11 @@ typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + +#define VK_GOOGLE_user_type 1 +#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1 +#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" + #ifdef __cplusplus } #endif diff --git a/util/test/demos/vk/vk_buffer_address.cpp b/util/test/demos/vk/vk_ext_buffer_address.cpp similarity index 96% rename from util/test/demos/vk/vk_buffer_address.cpp rename to util/test/demos/vk/vk_ext_buffer_address.cpp index 8027a5f13..bedcd2d6d 100644 --- a/util/test/demos/vk/vk_buffer_address.cpp +++ b/util/test/demos/vk/vk_ext_buffer_address.cpp @@ -30,9 +30,10 @@ #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || \ defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) -RD_TEST(VK_Buffer_Address, VulkanGraphicsTest) +RD_TEST(VK_EXT_Buffer_Address, VulkanGraphicsTest) { - static constexpr const char *Description = "Test capture and replay of VK_EXT_buffer_reference"; + static constexpr const char *Description = + "Test capture and replay of VK_EXT_buffer_device_address"; // should match definition below in GLSL struct DrawData @@ -124,8 +125,8 @@ void main() if(!Avail.empty()) return; - static VkPhysicalDeviceBufferAddressFeaturesEXT bufaddrFeatures = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + static VkPhysicalDeviceBufferDeviceAddressFeaturesEXT bufaddrFeatures = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, }; getPhysFeatures2(&bufaddrFeatures); diff --git a/util/test/demos/vk/vk_khr_buffer_address.cpp b/util/test/demos/vk/vk_khr_buffer_address.cpp new file mode 100644 index 000000000..854af20c6 --- /dev/null +++ b/util/test/demos/vk/vk_khr_buffer_address.cpp @@ -0,0 +1,319 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2018-2019 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "vk_test.h" + +// only support on 64-bit, just because it's easier to share CPU & GPU structs if pointer size is +// identical + +#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + +RD_TEST(VK_KHR_Buffer_Address, VulkanGraphicsTest) +{ + static constexpr const char *Description = + "Test capture and replay of VK_KHR_buffer_device_address"; + + // should match definition below in GLSL + struct DrawData + { + DefaultA2V *vert_data; + // no alignment on Vec4f, use scalar block layout + Vec4f tint; + Vec2f offset; + Vec2f scale; + // padding to make the struct size 16 to make aligning the buffer easier. + Vec2f padding; + }; + + std::string common = R"EOSHADER( + +#version 460 core + +#extension GL_EXT_buffer_reference : require +#extension GL_EXT_scalar_block_layout : require + +struct v2f +{ + vec4 pos; + vec4 col; + vec4 uv; +}; + +struct DefaultA2V { + vec3 pos; + vec4 col; + vec2 uv; +}; + +layout(buffer_reference, scalar, buffer_reference_align = 16) buffer TriangleData { + DefaultA2V verts[3]; +}; + +layout(buffer_reference, scalar, buffer_reference_align = 16) buffer DrawData { + TriangleData tri; + vec4 tint; + vec2 offset; + vec2 scale; +}; + +layout(push_constant) uniform PushData { + DrawData data_ptr; +} push; + +)EOSHADER"; + + const std::string vertex = R"EOSHADER( + +layout(location = 0) out v2f vertOut; + +void main() +{ + DrawData draw = push.data_ptr; + DefaultA2V vert = draw.tri.verts[gl_VertexIndex]; + + gl_Position = vertOut.pos = vec4(vert.pos*vec3(draw.scale,1) + vec3(draw.offset, 0), 1); + vertOut.col = vert.col; + vertOut.uv = vec4(vert.uv, 0, 1); +} + +)EOSHADER"; + + const std::string pixel = R"EOSHADER( + +layout(location = 0) in v2f vertIn; + +layout(location = 0, index = 0) out vec4 Color; + +void main() +{ + DrawData draw = push.data_ptr; + + Color = vertIn.col * draw.tint; +} + +)EOSHADER"; + + void Prepare(int argc, char **argv) + { + devExts.push_back(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME); + devExts.push_back(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME); + + VulkanGraphicsTest::Prepare(argc, argv); + + if(!Avail.empty()) + return; + + static VkPhysicalDeviceBufferDeviceAddressFeaturesKHR bufaddrFeatures = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, + }; + + getPhysFeatures2(&bufaddrFeatures); + + if(!bufaddrFeatures.bufferDeviceAddress) + Avail = "Buffer device address feature 'bufferDeviceAddress' not available"; + + devInfoNext = &bufaddrFeatures; + } + + int main() + { + // initialise, create window, create context, etc + if(!Init()) + return 3; + + VkPipelineLayout layout = createPipelineLayout( + vkh::PipelineLayoutCreateInfo({}, {vkh::PushConstantRange(VK_SHADER_STAGE_ALL, 0, 8)})); + + vkh::GraphicsPipelineCreateInfo pipeCreateInfo; + + pipeCreateInfo.layout = layout; + pipeCreateInfo.renderPass = mainWindow->rp; + + pipeCreateInfo.stages = { + CompileShaderModule(common + vertex, ShaderLang::glsl, ShaderStage::vert, "main"), + CompileShaderModule(common + pixel, ShaderLang::glsl, ShaderStage::frag, "main"), + }; + + VkPipeline pipe = createGraphicsPipeline(pipeCreateInfo); + + vkh::BufferCreateInfo bufinfo(0x100000, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR); + + VkMemoryAllocateInfo memoryAllocateInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; + VkMemoryAllocateFlagsInfo memoryAllocateFlags = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO}; + + memoryAllocateFlags.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR; + memoryAllocateInfo.pNext = &memoryAllocateFlags; + + const VkPhysicalDeviceMemoryProperties *memProps = NULL; + vmaGetMemoryProperties(allocator, &memProps); + + VkBuffer databuf; + vkCreateBuffer(device, bufinfo, NULL, &databuf); + + VkMemoryRequirements mrq; + vkGetBufferMemoryRequirements(device, databuf, &mrq); + + memoryAllocateInfo.allocationSize = mrq.size; + + for(uint32_t i = 0; i < memProps->memoryTypeCount; i++) + { + if((mrq.memoryTypeBits & (1u << i)) && + (memProps->memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) + { + memoryAllocateInfo.memoryTypeIndex = i; + break; + } + } + + VkDeviceMemory databufMem; + vkAllocateMemory(device, &memoryAllocateInfo, NULL, &databufMem); + vkBindBufferMemory(device, databuf, databufMem, 0); + + // north-facing primary colours triangle + const DefaultA2V tri1[3] = { + {Vec3f(-0.5f, -0.5f, 0.0f), Vec4f(1.0f, 0.0f, 0.0f, 1.0f), Vec2f(0.0f, 0.0f)}, + {Vec3f(0.0f, 0.5f, 0.0f), Vec4f(0.0f, 1.0f, 0.0f, 1.0f), Vec2f(0.0f, 1.0f)}, + {Vec3f(0.5f, -0.5f, 0.0f), Vec4f(0.0f, 0.0f, 1.0f, 1.0f), Vec2f(1.0f, 0.0f)}, + }; + + // north-west-facing triangle + const DefaultA2V tri2[3] = { + {Vec3f(-0.5f, 0.5f, 0.0f), Vec4f(1.0f, 0.2f, 1.0f, 1.0f), Vec2f(0.0f, 0.0f)}, + {Vec3f(0.5f, 0.5f, 0.0f), Vec4f(0.7f, 0.85f, 1.0f, 1.0f), Vec2f(0.0f, 1.0f)}, + {Vec3f(-0.5f, -0.5f, 0.0f), Vec4f(1.0f, 1.0f, 0.4f, 1.0f), Vec2f(1.0f, 0.0f)}, + }; + + VkBufferDeviceAddressInfoKHR info = {VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR}; + info.buffer = databuf; + + VkDeviceAddress baseAddr = vkGetBufferDeviceAddressKHR(device, &info); + byte *gpuptr = (byte *)baseAddr; // not a valid cpu pointer but useful for avoiding casting + + byte *cpuptr = NULL; + vkMapMemory(device, databufMem, 0, mrq.size, 0, (void **)&cpuptr); + + // put triangle data first + memcpy(cpuptr, tri1, sizeof(tri1)); + DefaultA2V *gputri1 = (DefaultA2V *)gpuptr; + cpuptr += sizeof(tri1); + gpuptr += sizeof(tri1); + + // align to 16 bytes + cpuptr = AlignUpPtr(cpuptr, 16); + gpuptr = AlignUpPtr(gpuptr, 16); + + memcpy(cpuptr, tri2, sizeof(tri2)); + DefaultA2V *gputri2 = (DefaultA2V *)gpuptr; + cpuptr += sizeof(tri2); + gpuptr += sizeof(tri2); + + // align to 16 bytes + cpuptr = AlignUpPtr(cpuptr, 16); + gpuptr = AlignUpPtr(gpuptr, 16); + + DrawData *drawscpu = (DrawData *)cpuptr; + DrawData *drawsgpu = (DrawData *)gpuptr; + + drawscpu[0].vert_data = gputri1; + drawscpu[0].offset = Vec2f(-0.5f, 0.0f); + drawscpu[0].scale = Vec2f(0.5f, 0.5f); + drawscpu[0].tint = Vec4f(1.0f, 0.5f, 0.5f, 1.0f); // tint red + + drawscpu[1].vert_data = gputri1; + drawscpu[1].offset = Vec2f(0.0f, 0.0f); + drawscpu[1].scale = Vec2f(0.5f, -0.5f); // flip vertically + drawscpu[1].tint = Vec4f(0.2f, 0.5f, 1.0f, 1.0f); // tint blue + + drawscpu[2].vert_data = gputri2; // use second triangle + drawscpu[2].offset = Vec2f(0.6f, 0.0f); + drawscpu[2].scale = Vec2f(0.5f, 0.5f); + drawscpu[2].tint = Vec4f(1.0f, 1.0f, 1.0f, 1.0f); + + float time = 0.0f; + + while(Running()) + { + VkCommandBuffer cmd = GetCommandBuffer(); + + vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo()); + + VkImage swapimg = + StartUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL); + + vkCmdClearColorImage(cmd, swapimg, VK_IMAGE_LAYOUT_GENERAL, + vkh::ClearColorValue(0.4f, 0.5f, 0.6f, 1.0f), 1, + vkh::ImageSubresourceRange()); + + vkCmdBeginRenderPass( + cmd, vkh::RenderPassBeginInfo(mainWindow->rp, mainWindow->GetFB(), mainWindow->scissor), + VK_SUBPASS_CONTENTS_INLINE); + + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe); + vkCmdSetViewport(cmd, 0, 1, &mainWindow->viewport); + vkCmdSetScissor(cmd, 0, 1, &mainWindow->scissor); + + // look ma, no binds + DrawData *bindptr = drawsgpu; + drawscpu[0].scale.x = (abs(sinf(time)) + 0.1f) * 0.5f; + vkCmdPushConstants(cmd, layout, VK_SHADER_STAGE_ALL, 0, 8, &bindptr); + vkCmdDraw(cmd, 3, 1, 0, 0); + + bindptr++; + drawscpu[1].scale.y = (abs(cosf(time)) + 0.1f) * 0.5f; + vkCmdPushConstants(cmd, layout, VK_SHADER_STAGE_ALL, 0, 8, &bindptr); + vkCmdDraw(cmd, 3, 1, 0, 0); + + bindptr++; + drawscpu[2].tint = Vec4f(cosf(time) * 0.5f + 0.5f, sinf(time) * 0.5f + 0.5f, + cosf(time + 3.14f) * 0.5f + 0.5f, 1.0f); + vkCmdPushConstants(cmd, layout, VK_SHADER_STAGE_ALL, 0, 8, &bindptr); + vkCmdDraw(cmd, 3, 1, 0, 0); + + vkCmdEndRenderPass(cmd); + + FinishUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL); + + vkEndCommandBuffer(cmd); + + Submit(0, 1, {cmd}); + + Present(); + + time += 0.1f; + } + + CHECK_VKR(vkDeviceWaitIdle(device)); + + vkDestroyBuffer(device, databuf, NULL); + vkUnmapMemory(device, databufMem); + vkFreeMemory(device, databufMem, NULL); + + return 0; + } +}; + +REGISTER_TEST(); + +#endif // if 64-bit \ No newline at end of file