From 59becd15f814a5022b70dfb7b3698624d2dceb11 Mon Sep 17 00:00:00 2001 From: Jeremy Gebben Date: Mon, 11 Sep 2023 09:06:24 -0600 Subject: [PATCH] build: Update Vulkan-Headers to 1.3.264 --- scripts/known_good.json | 2 +- utils/generated/vk_safe_struct.cpp | 306 ++++++++++++++++++++++++++++ utils/generated/vk_safe_struct.h | 53 +++++ utils/generated/vk_typemap_helper.h | 27 +++ 4 files changed, 387 insertions(+), 1 deletion(-) diff --git a/scripts/known_good.json b/scripts/known_good.json index 7a0e962f..da448ad5 100755 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -6,7 +6,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.3.263" + "commit": "v1.3.264" }, { "name": "Vulkan-Utility-Libraries", diff --git a/utils/generated/vk_safe_struct.cpp b/utils/generated/vk_safe_struct.cpp index abfbff52..5b4bd8e8 100644 --- a/utils/generated/vk_safe_struct.cpp +++ b/utils/generated/vk_safe_struct.cpp @@ -57648,6 +57648,238 @@ void safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::initialize(const safe_V pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct) : + sType(in_struct->sType), + frameBoundary(in_struct->frameBoundary) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT() : + sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT), + pNext(nullptr), + frameBoundary() +{} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) +{ + sType = copy_src.sType; + frameBoundary = copy_src.frameBoundary; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::operator=(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + frameBoundary = copy_src.frameBoundary; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + frameBoundary = in_struct->frameBoundary; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src) +{ + sType = copy_src->sType; + frameBoundary = copy_src->frameBoundary; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct) : + sType(in_struct->sType), + flags(in_struct->flags), + frameID(in_struct->frameID), + imageCount(in_struct->imageCount), + pImages(nullptr), + bufferCount(in_struct->bufferCount), + pBuffers(nullptr), + tagName(in_struct->tagName), + tagSize(in_struct->tagSize), + pTag(in_struct->pTag) +{ + pNext = SafePnextCopy(in_struct->pNext); + if (imageCount && in_struct->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = in_struct->pImages[i]; + } + } + if (bufferCount && in_struct->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = in_struct->pBuffers[i]; + } + } +} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT() : + sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT), + pNext(nullptr), + flags(), + frameID(), + imageCount(), + pImages(nullptr), + bufferCount(), + pBuffers(nullptr), + tagName(), + tagSize(), + pTag(nullptr) +{} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src) +{ + sType = copy_src.sType; + flags = copy_src.flags; + frameID = copy_src.frameID; + imageCount = copy_src.imageCount; + pImages = nullptr; + bufferCount = copy_src.bufferCount; + pBuffers = nullptr; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + if (imageCount && copy_src.pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src.pImages[i]; + } + } + if (bufferCount && copy_src.pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src.pBuffers[i]; + } + } +} + +safe_VkFrameBoundaryEXT& safe_VkFrameBoundaryEXT::operator=(const safe_VkFrameBoundaryEXT& copy_src) +{ + if (©_src == this) return *this; + + if (pImages) + delete[] pImages; + if (pBuffers) + delete[] pBuffers; + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + frameID = copy_src.frameID; + imageCount = copy_src.imageCount; + pImages = nullptr; + bufferCount = copy_src.bufferCount; + pBuffers = nullptr; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + if (imageCount && copy_src.pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src.pImages[i]; + } + } + if (bufferCount && copy_src.pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src.pBuffers[i]; + } + } + + return *this; +} + +safe_VkFrameBoundaryEXT::~safe_VkFrameBoundaryEXT() +{ + if (pImages) + delete[] pImages; + if (pBuffers) + delete[] pBuffers; + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkFrameBoundaryEXT::initialize(const VkFrameBoundaryEXT* in_struct) +{ + if (pImages) + delete[] pImages; + if (pBuffers) + delete[] pBuffers; + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + frameID = in_struct->frameID; + imageCount = in_struct->imageCount; + pImages = nullptr; + bufferCount = in_struct->bufferCount; + pBuffers = nullptr; + tagName = in_struct->tagName; + tagSize = in_struct->tagSize; + pTag = in_struct->pTag; + pNext = SafePnextCopy(in_struct->pNext); + if (imageCount && in_struct->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = in_struct->pImages[i]; + } + } + if (bufferCount && in_struct->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = in_struct->pBuffers[i]; + } + } +} + +void safe_VkFrameBoundaryEXT::initialize(const safe_VkFrameBoundaryEXT* copy_src) +{ + sType = copy_src->sType; + flags = copy_src->flags; + frameID = copy_src->frameID; + imageCount = copy_src->imageCount; + pImages = nullptr; + bufferCount = copy_src->bufferCount; + pBuffers = nullptr; + tagName = copy_src->tagName; + tagSize = copy_src->tagSize; + pTag = copy_src->pTag; + pNext = SafePnextCopy(copy_src->pNext); + if (imageCount && copy_src->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src->pImages[i]; + } + } + if (bufferCount && copy_src->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src->pBuffers[i]; + } + } +} + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct) : sType(in_struct->sType), multisampledRenderToSingleSampled(in_struct->multisampledRenderToSingleSampled) @@ -65512,6 +65744,62 @@ void safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize(cons #endif // VK_USE_PLATFORM_SCREEN_QNX +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct) : + sType(in_struct->sType), + underlyingAPI(in_struct->underlyingAPI) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT() : + sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT), + pNext(nullptr), + underlyingAPI() +{} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) +{ + sType = copy_src.sType; + underlyingAPI = copy_src.underlyingAPI; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::operator=(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + underlyingAPI = copy_src.underlyingAPI; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + underlyingAPI = in_struct->underlyingAPI; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src) +{ + sType = copy_src->sType; + underlyingAPI = copy_src->underlyingAPI; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct) : sType(in_struct->sType), descriptorPoolOverallocation(in_struct->descriptorPoolOverallocation) @@ -68996,6 +69284,12 @@ void *SafePnextCopy(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(reinterpret_cast(pNext)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + safe_pNext = new safe_VkFrameBoundaryEXT(reinterpret_cast(pNext)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(reinterpret_cast(pNext)); break; @@ -69242,6 +69536,9 @@ void *SafePnextCopy(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(reinterpret_cast(pNext)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + safe_pNext = new safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(reinterpret_cast(pNext)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast(pNext)); break; @@ -70614,6 +70911,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: delete reinterpret_cast(header); break; @@ -70860,6 +71163,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: delete reinterpret_cast(header); break; diff --git a/utils/generated/vk_safe_struct.h b/utils/generated/vk_safe_struct.h index 7ef7044d..44acb17c 100644 --- a/utils/generated/vk_safe_struct.h +++ b/utils/generated/vk_safe_struct.h @@ -12595,6 +12595,44 @@ struct safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT { VkPhysicalDevicePipelinePropertiesFeaturesEXT const *ptr() const { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 frameBoundary; + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& operator=(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(); + ~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(); + void initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct); + void initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src); + VkPhysicalDeviceFrameBoundaryFeaturesEXT *ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFrameBoundaryFeaturesEXT const *ptr() const { return reinterpret_cast(this); } +}; + +struct safe_VkFrameBoundaryEXT { + VkStructureType sType; + const void* pNext{}; + VkFrameBoundaryFlagsEXT flags; + uint64_t frameID; + uint32_t imageCount; + VkImage* pImages{}; + uint32_t bufferCount; + VkBuffer* pBuffers{}; + uint64_t tagName; + size_t tagSize; + const void* pTag{}; + safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct); + safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src); + safe_VkFrameBoundaryEXT& operator=(const safe_VkFrameBoundaryEXT& copy_src); + safe_VkFrameBoundaryEXT(); + ~safe_VkFrameBoundaryEXT(); + void initialize(const VkFrameBoundaryEXT* in_struct); + void initialize(const safe_VkFrameBoundaryEXT* copy_src); + VkFrameBoundaryEXT *ptr() { return reinterpret_cast(this); } + VkFrameBoundaryEXT const *ptr() const { return reinterpret_cast(this); } +}; + struct safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { VkStructureType sType; void* pNext{}; @@ -14434,6 +14472,21 @@ struct safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX { }; #endif // VK_USE_PLATFORM_SCREEN_QNX +struct safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT { + VkStructureType sType; + void* pNext{}; + VkLayeredDriverUnderlyingApiMSFT underlyingAPI; + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& operator=(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(); + ~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(); + void initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct); + void initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src); + VkPhysicalDeviceLayeredDriverPropertiesMSFT *ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceLayeredDriverPropertiesMSFT const *ptr() const { return reinterpret_cast(this); } +}; + struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { VkStructureType sType; void* pNext{}; diff --git a/utils/generated/vk_typemap_helper.h b/utils/generated/vk_typemap_helper.h index f72d8eac..cbfc1c2c 100644 --- a/utils/generated/vk_typemap_helper.h +++ b/utils/generated/vk_typemap_helper.h @@ -6482,6 +6482,24 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFrameBoundaryFeaturesEXT Type; +}; + +// Map type VkFrameBoundaryEXT to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkFrameBoundaryEXT Type; +}; + // Map type VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; @@ -7481,6 +7499,15 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLayeredDriverPropertiesMSFT Type; +}; + // Map type VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;