From 06c34c799baa34fb030901f12f1dfac70ab78692 Mon Sep 17 00:00:00 2001 From: "headerbot[bot]" <(none)> Date: Thu, 7 May 2026 19:26:04 -0700 Subject: [PATCH] build: Update to header v1.4.351 --- CMakeLists.txt | 2 +- include/vulkan/utility/vk_dispatch_table.h | 24 + include/vulkan/utility/vk_safe_struct.hpp | 363 +++++++++ include/vulkan/utility/vk_struct_helper.hpp | 18 + include/vulkan/vk_enum_string_helper.h | 355 ++++++++- scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_ext.cpp | 100 +++ src/vulkan/vk_safe_struct_khr.cpp | 366 ++++++++++ src/vulkan/vk_safe_struct_utils.cpp | 78 ++ src/vulkan/vk_safe_struct_vendor.cpp | 768 ++++++++++++++++++++ 10 files changed, 2035 insertions(+), 41 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 8d63662..e2febfa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.22.1) # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script -project(VUL VERSION 1.4.350 LANGUAGES CXX) +project(VUL VERSION 1.4.351 LANGUAGES CXX) set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143 diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index f87414d..0683acd 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -588,6 +588,18 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkGetAndroidHardwareBufferPropertiesANDROID GetAndroidHardwareBufferPropertiesANDROID; PFN_vkGetMemoryAndroidHardwareBufferANDROID GetMemoryAndroidHardwareBufferANDROID; #endif // VK_USE_PLATFORM_ANDROID_KHR + PFN_vkCreateGpaSessionAMD CreateGpaSessionAMD; + PFN_vkDestroyGpaSessionAMD DestroyGpaSessionAMD; + PFN_vkSetGpaDeviceClockModeAMD SetGpaDeviceClockModeAMD; + PFN_vkGetGpaDeviceClockInfoAMD GetGpaDeviceClockInfoAMD; + PFN_vkCmdBeginGpaSessionAMD CmdBeginGpaSessionAMD; + PFN_vkCmdEndGpaSessionAMD CmdEndGpaSessionAMD; + PFN_vkCmdBeginGpaSampleAMD CmdBeginGpaSampleAMD; + PFN_vkCmdEndGpaSampleAMD CmdEndGpaSampleAMD; + PFN_vkGetGpaSessionStatusAMD GetGpaSessionStatusAMD; + PFN_vkGetGpaSessionResultsAMD GetGpaSessionResultsAMD; + PFN_vkResetGpaSessionAMD ResetGpaSessionAMD; + PFN_vkCmdCopyGpaSessionResultsAMD CmdCopyGpaSessionResultsAMD; #ifdef VK_ENABLE_BETA_EXTENSIONS PFN_vkCreateExecutionGraphPipelinesAMDX CreateExecutionGraphPipelinesAMDX; PFN_vkGetExecutionGraphPipelineScratchSizeAMDX GetExecutionGraphPipelineScratchSizeAMDX; @@ -1319,6 +1331,18 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->GetAndroidHardwareBufferPropertiesANDROID = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)gdpa(device, "vkGetAndroidHardwareBufferPropertiesANDROID"); table->GetMemoryAndroidHardwareBufferANDROID = (PFN_vkGetMemoryAndroidHardwareBufferANDROID)gdpa(device, "vkGetMemoryAndroidHardwareBufferANDROID"); #endif // VK_USE_PLATFORM_ANDROID_KHR + table->CreateGpaSessionAMD = (PFN_vkCreateGpaSessionAMD)gdpa(device, "vkCreateGpaSessionAMD"); + table->DestroyGpaSessionAMD = (PFN_vkDestroyGpaSessionAMD)gdpa(device, "vkDestroyGpaSessionAMD"); + table->SetGpaDeviceClockModeAMD = (PFN_vkSetGpaDeviceClockModeAMD)gdpa(device, "vkSetGpaDeviceClockModeAMD"); + table->GetGpaDeviceClockInfoAMD = (PFN_vkGetGpaDeviceClockInfoAMD)gdpa(device, "vkGetGpaDeviceClockInfoAMD"); + table->CmdBeginGpaSessionAMD = (PFN_vkCmdBeginGpaSessionAMD)gdpa(device, "vkCmdBeginGpaSessionAMD"); + table->CmdEndGpaSessionAMD = (PFN_vkCmdEndGpaSessionAMD)gdpa(device, "vkCmdEndGpaSessionAMD"); + table->CmdBeginGpaSampleAMD = (PFN_vkCmdBeginGpaSampleAMD)gdpa(device, "vkCmdBeginGpaSampleAMD"); + table->CmdEndGpaSampleAMD = (PFN_vkCmdEndGpaSampleAMD)gdpa(device, "vkCmdEndGpaSampleAMD"); + table->GetGpaSessionStatusAMD = (PFN_vkGetGpaSessionStatusAMD)gdpa(device, "vkGetGpaSessionStatusAMD"); + table->GetGpaSessionResultsAMD = (PFN_vkGetGpaSessionResultsAMD)gdpa(device, "vkGetGpaSessionResultsAMD"); + table->ResetGpaSessionAMD = (PFN_vkResetGpaSessionAMD)gdpa(device, "vkResetGpaSessionAMD"); + table->CmdCopyGpaSessionResultsAMD = (PFN_vkCmdCopyGpaSessionResultsAMD)gdpa(device, "vkCmdCopyGpaSessionResultsAMD"); #ifdef VK_ENABLE_BETA_EXTENSIONS table->CreateExecutionGraphPipelinesAMDX = (PFN_vkCreateExecutionGraphPipelinesAMDX)gdpa(device, "vkCreateExecutionGraphPipelinesAMDX"); table->GetExecutionGraphPipelineScratchSizeAMDX = (PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)gdpa(device, "vkGetExecutionGraphPipelineScratchSizeAMDX"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 53be04e..63eae18 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -10952,6 +10952,101 @@ struct safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { return reinterpret_cast(this); } }; +struct safe_VkAccelerationStructureGeometryMicromapDataKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t usageCountsCount; + const VkMicromapUsageKHR* pUsageCounts{}; + const VkMicromapUsageKHR* const* ppUsageCounts{}; + VkDeviceAddress data; + VkDeviceAddress triangleArray; + VkDeviceSize triangleArrayStride; + + safe_VkAccelerationStructureGeometryMicromapDataKHR(const VkAccelerationStructureGeometryMicromapDataKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryMicromapDataKHR(const safe_VkAccelerationStructureGeometryMicromapDataKHR& copy_src); + safe_VkAccelerationStructureGeometryMicromapDataKHR& operator=( + const safe_VkAccelerationStructureGeometryMicromapDataKHR& copy_src); + safe_VkAccelerationStructureGeometryMicromapDataKHR(); + ~safe_VkAccelerationStructureGeometryMicromapDataKHR(); + void initialize(const VkAccelerationStructureGeometryMicromapDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryMicromapDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryMicromapDataKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureGeometryMicromapDataKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 micromap; + + safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR(const VkPhysicalDeviceOpacityMicromapFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR(const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& copy_src); + safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& operator=(const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& copy_src); + safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR(); + ~safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR(); + void initialize(const VkPhysicalDeviceOpacityMicromapFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpacityMicromapFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceOpacityMicromapFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + uint32_t maxOpacityLossy4StateSubdivisionLevel; + uint64_t maxMicromapTriangles; + + safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR(const VkPhysicalDeviceOpacityMicromapPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR(const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& copy_src); + safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& operator=(const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& copy_src); + safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR(); + ~safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR(); + void initialize(const VkPhysicalDeviceOpacityMicromapPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpacityMicromapPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceOpacityMicromapPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureTrianglesOpacityMicromapKHR { + VkStructureType sType; + void* pNext{}; + VkIndexType indexType; + VkDeviceAddress indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + VkAccelerationStructureKHR micromap; + + safe_VkAccelerationStructureTrianglesOpacityMicromapKHR(const VkAccelerationStructureTrianglesOpacityMicromapKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureTrianglesOpacityMicromapKHR( + const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& copy_src); + safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& operator=( + const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& copy_src); + safe_VkAccelerationStructureTrianglesOpacityMicromapKHR(); + ~safe_VkAccelerationStructureTrianglesOpacityMicromapKHR(); + void initialize(const VkAccelerationStructureTrianglesOpacityMicromapKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureTrianglesOpacityMicromapKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureTrianglesOpacityMicromapKHR const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceMaintenance10FeaturesKHR { VkStructureType sType; void* pNext{}; @@ -12334,6 +12429,144 @@ struct safe_VkAndroidHardwareBufferFormatProperties2ANDROID { } }; #endif // VK_USE_PLATFORM_ANDROID_KHR +struct safe_VkPhysicalDeviceGpaFeaturesAMD { + VkStructureType sType; + void* pNext{}; + VkBool32 perfCounters; + VkBool32 streamingPerfCounters; + VkBool32 sqThreadTracing; + VkBool32 clockModes; + + safe_VkPhysicalDeviceGpaFeaturesAMD(const VkPhysicalDeviceGpaFeaturesAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceGpaFeaturesAMD(const safe_VkPhysicalDeviceGpaFeaturesAMD& copy_src); + safe_VkPhysicalDeviceGpaFeaturesAMD& operator=(const safe_VkPhysicalDeviceGpaFeaturesAMD& copy_src); + safe_VkPhysicalDeviceGpaFeaturesAMD(); + ~safe_VkPhysicalDeviceGpaFeaturesAMD(); + void initialize(const VkPhysicalDeviceGpaFeaturesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGpaFeaturesAMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGpaFeaturesAMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceGpaFeaturesAMD const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceGpaPropertiesAMD { + VkStructureType sType; + void* pNext{}; + VkPhysicalDeviceGpaPropertiesFlagsAMD flags; + VkDeviceSize maxSqttSeBufferSize; + uint32_t shaderEngineCount; + uint32_t perfBlockCount; + VkGpaPerfBlockPropertiesAMD* pPerfBlocks{}; + + safe_VkPhysicalDeviceGpaPropertiesAMD(const VkPhysicalDeviceGpaPropertiesAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceGpaPropertiesAMD(const safe_VkPhysicalDeviceGpaPropertiesAMD& copy_src); + safe_VkPhysicalDeviceGpaPropertiesAMD& operator=(const safe_VkPhysicalDeviceGpaPropertiesAMD& copy_src); + safe_VkPhysicalDeviceGpaPropertiesAMD(); + ~safe_VkPhysicalDeviceGpaPropertiesAMD(); + void initialize(const VkPhysicalDeviceGpaPropertiesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGpaPropertiesAMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGpaPropertiesAMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceGpaPropertiesAMD const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceGpaProperties2AMD { + VkStructureType sType; + void* pNext{}; + uint32_t revisionId; + + safe_VkPhysicalDeviceGpaProperties2AMD(const VkPhysicalDeviceGpaProperties2AMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceGpaProperties2AMD(const safe_VkPhysicalDeviceGpaProperties2AMD& copy_src); + safe_VkPhysicalDeviceGpaProperties2AMD& operator=(const safe_VkPhysicalDeviceGpaProperties2AMD& copy_src); + safe_VkPhysicalDeviceGpaProperties2AMD(); + ~safe_VkPhysicalDeviceGpaProperties2AMD(); + void initialize(const VkPhysicalDeviceGpaProperties2AMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGpaProperties2AMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGpaProperties2AMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceGpaProperties2AMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGpaSampleBeginInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkGpaSampleTypeAMD sampleType; + VkBool32 sampleInternalOperations; + VkBool32 cacheFlushOnCounterCollection; + VkBool32 sqShaderMaskEnable; + VkGpaSqShaderStageFlagsAMD sqShaderMask; + uint32_t perfCounterCount; + const VkGpaPerfCounterAMD* pPerfCounters{}; + uint32_t streamingPerfTraceSampleInterval; + VkDeviceSize perfCounterDeviceMemoryLimit; + VkBool32 sqThreadTraceEnable; + VkBool32 sqThreadTraceSuppressInstructionTokens; + VkDeviceSize sqThreadTraceDeviceMemoryLimit; + VkPipelineStageFlags timingPreSample; + VkPipelineStageFlags timingPostSample; + + safe_VkGpaSampleBeginInfoAMD(const VkGpaSampleBeginInfoAMD* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGpaSampleBeginInfoAMD(const safe_VkGpaSampleBeginInfoAMD& copy_src); + safe_VkGpaSampleBeginInfoAMD& operator=(const safe_VkGpaSampleBeginInfoAMD& copy_src); + safe_VkGpaSampleBeginInfoAMD(); + ~safe_VkGpaSampleBeginInfoAMD(); + void initialize(const VkGpaSampleBeginInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGpaSampleBeginInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkGpaSampleBeginInfoAMD* ptr() { return reinterpret_cast(this); } + VkGpaSampleBeginInfoAMD const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGpaDeviceClockModeInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkGpaDeviceClockModeAMD clockMode; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + + safe_VkGpaDeviceClockModeInfoAMD(const VkGpaDeviceClockModeInfoAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGpaDeviceClockModeInfoAMD(const safe_VkGpaDeviceClockModeInfoAMD& copy_src); + safe_VkGpaDeviceClockModeInfoAMD& operator=(const safe_VkGpaDeviceClockModeInfoAMD& copy_src); + safe_VkGpaDeviceClockModeInfoAMD(); + ~safe_VkGpaDeviceClockModeInfoAMD(); + void initialize(const VkGpaDeviceClockModeInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGpaDeviceClockModeInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkGpaDeviceClockModeInfoAMD* ptr() { return reinterpret_cast(this); } + VkGpaDeviceClockModeInfoAMD const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGpaDeviceGetClockInfoAMD { + VkStructureType sType; + void* pNext{}; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + uint32_t memoryClockFrequency; + uint32_t engineClockFrequency; + + safe_VkGpaDeviceGetClockInfoAMD(const VkGpaDeviceGetClockInfoAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGpaDeviceGetClockInfoAMD(const safe_VkGpaDeviceGetClockInfoAMD& copy_src); + safe_VkGpaDeviceGetClockInfoAMD& operator=(const safe_VkGpaDeviceGetClockInfoAMD& copy_src); + safe_VkGpaDeviceGetClockInfoAMD(); + ~safe_VkGpaDeviceGetClockInfoAMD(); + void initialize(const VkGpaDeviceGetClockInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGpaDeviceGetClockInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkGpaDeviceGetClockInfoAMD* ptr() { return reinterpret_cast(this); } + VkGpaDeviceGetClockInfoAMD const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGpaSessionCreateInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkGpaSessionAMD secondaryCopySource; + + safe_VkGpaSessionCreateInfoAMD(const VkGpaSessionCreateInfoAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGpaSessionCreateInfoAMD(const safe_VkGpaSessionCreateInfoAMD& copy_src); + safe_VkGpaSessionCreateInfoAMD& operator=(const safe_VkGpaSessionCreateInfoAMD& copy_src); + safe_VkGpaSessionCreateInfoAMD(); + ~safe_VkGpaSessionCreateInfoAMD(); + void initialize(const VkGpaSessionCreateInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGpaSessionCreateInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkGpaSessionCreateInfoAMD* ptr() { return reinterpret_cast(this); } + VkGpaSessionCreateInfoAMD const* ptr() const { return reinterpret_cast(this); } +}; #ifdef VK_ENABLE_BETA_EXTENSIONS struct safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX { VkStructureType sType; @@ -13889,6 +14122,27 @@ struct safe_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 elapsedTimerQuery; + + safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& operator=( + const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(); + ~safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(); + void initialize(const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkImportMemoryHostPointerInfoEXT { VkStructureType sType; const void* pNext{}; @@ -16023,6 +16277,115 @@ struct safe_VkPhysicalDeviceQueuePerfHintPropertiesQCOM { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 imageGatherLinear; + VkBool32 imageGatherExtendedModes; + VkBool32 blockMatchExtendedClampToEdge; + + safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM(const VkPhysicalDeviceImageProcessing3FeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM(const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& operator=(const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM(); + ~safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM(); + void initialize(const VkPhysicalDeviceImageProcessing3FeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageProcessing3FeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageProcessing3FeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderMultipleWaitQueues; + + safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM(const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& operator=( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM(); + ~safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM(); + void initialize(const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM { + VkStructureType sType; + void* pNext{}; + uint32_t maxShaderWaitQueues; + + safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( + const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& operator=( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM(); + ~safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM(); + void initialize(const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSplitBarrier; + + safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& operator=( + const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(); + ~safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t splitBarrierReservedSharedMemory; + + safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& operator=( + const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(); + ~safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(); + void initialize(const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; #ifdef VK_ENABLE_BETA_EXTENSIONS struct safe_VkCudaModuleCreateInfoNV { VkStructureType sType; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index 73967a8..72bac55 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -574,6 +574,10 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR; } @@ -657,6 +661,13 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; } #endif // VK_USE_PLATFORM_ANDROID_KHR +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD; } #ifdef VK_ENABLE_BETA_EXTENSIONS template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; } @@ -722,6 +733,7 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; } @@ -834,6 +846,11 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; } #ifdef VK_ENABLE_BETA_EXTENSIONS template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; } @@ -1413,6 +1430,7 @@ template<> inline VkObjectType GetObjectType() { retur template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_CU_MODULE_NVX; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_GPA_SESSION_AMD; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_TENSOR_ARM; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_VALIDATION_CACHE_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index 9cd817e..ccf5f3d 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -994,6 +994,20 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD"; + case VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD: + return "VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD"; + case VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD: + return "VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD"; + case VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD: + return "VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD"; + case VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD: + return "VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD"; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX"; @@ -1168,6 +1182,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"; case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: @@ -1458,6 +1474,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV"; @@ -2492,6 +2518,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: + return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: + return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: @@ -2650,6 +2684,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) { return "VK_OBJECT_TYPE_CU_FUNCTION_NVX"; case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"; + case VK_OBJECT_TYPE_GPA_SESSION_AMD: + return "VK_OBJECT_TYPE_GPA_SESSION_AMD"; case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"; case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: @@ -3404,6 +3440,8 @@ static inline const char* string_VkQueryType(VkQueryType input_value) { return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"; case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"; + case VK_QUERY_TYPE_TIME_ELAPSED_QCOM: + return "VK_QUERY_TYPE_TIME_ELAPSED_QCOM"; case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"; case VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: @@ -4592,6 +4630,8 @@ static inline const char* string_VkAccelerationStructureTypeKHR(VkAccelerationSt return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR"; case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: return "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR"; + case VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR: + return "VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR"; default: return "Unhandled VkAccelerationStructureTypeKHR"; } @@ -4746,6 +4786,40 @@ static inline const char* string_VkDefaultVertexAttributeValueKHR(VkDefaultVerte return "Unhandled VkDefaultVertexAttributeValueKHR"; } } +static inline const char* string_VkOpacityMicromapFormatKHR(VkOpacityMicromapFormatKHR input_value) { + switch (input_value) { + case VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR: + return "VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR"; + case VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR: + return "VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR"; + default: + return "Unhandled VkOpacityMicromapFormatKHR"; + } +} +static inline const char* string_VkOpacityMicromapSpecialIndexKHR(VkOpacityMicromapSpecialIndexKHR input_value) { + switch (input_value) { + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR: + return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR"; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR: + return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR"; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR: + return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR"; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR: + return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR"; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: + return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV"; + default: + return "Unhandled VkOpacityMicromapSpecialIndexKHR"; + } +} +static inline const char* string_VkAccelerationStructureSerializedBlockTypeKHR(VkAccelerationStructureSerializedBlockTypeKHR input_value) { + switch (input_value) { + case VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR: + return "VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR"; + default: + return "Unhandled VkAccelerationStructureSerializedBlockTypeKHR"; + } +} static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value) { switch (input_value) { case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: @@ -4938,6 +5012,156 @@ static inline const char* string_VkConservativeRasterizationModeEXT(VkConservati return "Unhandled VkConservativeRasterizationModeEXT"; } } +static inline const char* string_VkGpaPerfBlockAMD(VkGpaPerfBlockAMD input_value) { + switch (input_value) { + case VK_GPA_PERF_BLOCK_CPF_AMD: + return "VK_GPA_PERF_BLOCK_CPF_AMD"; + case VK_GPA_PERF_BLOCK_IA_AMD: + return "VK_GPA_PERF_BLOCK_IA_AMD"; + case VK_GPA_PERF_BLOCK_VGT_AMD: + return "VK_GPA_PERF_BLOCK_VGT_AMD"; + case VK_GPA_PERF_BLOCK_PA_AMD: + return "VK_GPA_PERF_BLOCK_PA_AMD"; + case VK_GPA_PERF_BLOCK_SC_AMD: + return "VK_GPA_PERF_BLOCK_SC_AMD"; + case VK_GPA_PERF_BLOCK_SPI_AMD: + return "VK_GPA_PERF_BLOCK_SPI_AMD"; + case VK_GPA_PERF_BLOCK_SQ_AMD: + return "VK_GPA_PERF_BLOCK_SQ_AMD"; + case VK_GPA_PERF_BLOCK_SX_AMD: + return "VK_GPA_PERF_BLOCK_SX_AMD"; + case VK_GPA_PERF_BLOCK_TA_AMD: + return "VK_GPA_PERF_BLOCK_TA_AMD"; + case VK_GPA_PERF_BLOCK_TD_AMD: + return "VK_GPA_PERF_BLOCK_TD_AMD"; + case VK_GPA_PERF_BLOCK_TCP_AMD: + return "VK_GPA_PERF_BLOCK_TCP_AMD"; + case VK_GPA_PERF_BLOCK_TCC_AMD: + return "VK_GPA_PERF_BLOCK_TCC_AMD"; + case VK_GPA_PERF_BLOCK_TCA_AMD: + return "VK_GPA_PERF_BLOCK_TCA_AMD"; + case VK_GPA_PERF_BLOCK_DB_AMD: + return "VK_GPA_PERF_BLOCK_DB_AMD"; + case VK_GPA_PERF_BLOCK_CB_AMD: + return "VK_GPA_PERF_BLOCK_CB_AMD"; + case VK_GPA_PERF_BLOCK_GDS_AMD: + return "VK_GPA_PERF_BLOCK_GDS_AMD"; + case VK_GPA_PERF_BLOCK_SRBM_AMD: + return "VK_GPA_PERF_BLOCK_SRBM_AMD"; + case VK_GPA_PERF_BLOCK_GRBM_AMD: + return "VK_GPA_PERF_BLOCK_GRBM_AMD"; + case VK_GPA_PERF_BLOCK_GRBM_SE_AMD: + return "VK_GPA_PERF_BLOCK_GRBM_SE_AMD"; + case VK_GPA_PERF_BLOCK_RLC_AMD: + return "VK_GPA_PERF_BLOCK_RLC_AMD"; + case VK_GPA_PERF_BLOCK_DMA_AMD: + return "VK_GPA_PERF_BLOCK_DMA_AMD"; + case VK_GPA_PERF_BLOCK_MC_AMD: + return "VK_GPA_PERF_BLOCK_MC_AMD"; + case VK_GPA_PERF_BLOCK_CPG_AMD: + return "VK_GPA_PERF_BLOCK_CPG_AMD"; + case VK_GPA_PERF_BLOCK_CPC_AMD: + return "VK_GPA_PERF_BLOCK_CPC_AMD"; + case VK_GPA_PERF_BLOCK_WD_AMD: + return "VK_GPA_PERF_BLOCK_WD_AMD"; + case VK_GPA_PERF_BLOCK_TCS_AMD: + return "VK_GPA_PERF_BLOCK_TCS_AMD"; + case VK_GPA_PERF_BLOCK_ATC_AMD: + return "VK_GPA_PERF_BLOCK_ATC_AMD"; + case VK_GPA_PERF_BLOCK_ATC_L2_AMD: + return "VK_GPA_PERF_BLOCK_ATC_L2_AMD"; + case VK_GPA_PERF_BLOCK_MC_VM_L2_AMD: + return "VK_GPA_PERF_BLOCK_MC_VM_L2_AMD"; + case VK_GPA_PERF_BLOCK_EA_AMD: + return "VK_GPA_PERF_BLOCK_EA_AMD"; + case VK_GPA_PERF_BLOCK_RPB_AMD: + return "VK_GPA_PERF_BLOCK_RPB_AMD"; + case VK_GPA_PERF_BLOCK_RMI_AMD: + return "VK_GPA_PERF_BLOCK_RMI_AMD"; + case VK_GPA_PERF_BLOCK_UMCCH_AMD: + return "VK_GPA_PERF_BLOCK_UMCCH_AMD"; + case VK_GPA_PERF_BLOCK_GE_AMD: + return "VK_GPA_PERF_BLOCK_GE_AMD"; + case VK_GPA_PERF_BLOCK_GL1A_AMD: + return "VK_GPA_PERF_BLOCK_GL1A_AMD"; + case VK_GPA_PERF_BLOCK_GL1C_AMD: + return "VK_GPA_PERF_BLOCK_GL1C_AMD"; + case VK_GPA_PERF_BLOCK_GL1CG_AMD: + return "VK_GPA_PERF_BLOCK_GL1CG_AMD"; + case VK_GPA_PERF_BLOCK_GL2A_AMD: + return "VK_GPA_PERF_BLOCK_GL2A_AMD"; + case VK_GPA_PERF_BLOCK_GL2C_AMD: + return "VK_GPA_PERF_BLOCK_GL2C_AMD"; + case VK_GPA_PERF_BLOCK_CHA_AMD: + return "VK_GPA_PERF_BLOCK_CHA_AMD"; + case VK_GPA_PERF_BLOCK_CHC_AMD: + return "VK_GPA_PERF_BLOCK_CHC_AMD"; + case VK_GPA_PERF_BLOCK_CHCG_AMD: + return "VK_GPA_PERF_BLOCK_CHCG_AMD"; + case VK_GPA_PERF_BLOCK_GUS_AMD: + return "VK_GPA_PERF_BLOCK_GUS_AMD"; + case VK_GPA_PERF_BLOCK_GCR_AMD: + return "VK_GPA_PERF_BLOCK_GCR_AMD"; + case VK_GPA_PERF_BLOCK_PH_AMD: + return "VK_GPA_PERF_BLOCK_PH_AMD"; + case VK_GPA_PERF_BLOCK_UTCL1_AMD: + return "VK_GPA_PERF_BLOCK_UTCL1_AMD"; + case VK_GPA_PERF_BLOCK_GE_DIST_AMD: + return "VK_GPA_PERF_BLOCK_GE_DIST_AMD"; + case VK_GPA_PERF_BLOCK_GE_SE_AMD: + return "VK_GPA_PERF_BLOCK_GE_SE_AMD"; + case VK_GPA_PERF_BLOCK_DF_MALL_AMD: + return "VK_GPA_PERF_BLOCK_DF_MALL_AMD"; + case VK_GPA_PERF_BLOCK_SQ_WGP_AMD: + return "VK_GPA_PERF_BLOCK_SQ_WGP_AMD"; + case VK_GPA_PERF_BLOCK_PC_AMD: + return "VK_GPA_PERF_BLOCK_PC_AMD"; + case VK_GPA_PERF_BLOCK_GL1XA_AMD: + return "VK_GPA_PERF_BLOCK_GL1XA_AMD"; + case VK_GPA_PERF_BLOCK_GL1XC_AMD: + return "VK_GPA_PERF_BLOCK_GL1XC_AMD"; + case VK_GPA_PERF_BLOCK_WGS_AMD: + return "VK_GPA_PERF_BLOCK_WGS_AMD"; + case VK_GPA_PERF_BLOCK_EACPWD_AMD: + return "VK_GPA_PERF_BLOCK_EACPWD_AMD"; + case VK_GPA_PERF_BLOCK_EASE_AMD: + return "VK_GPA_PERF_BLOCK_EASE_AMD"; + case VK_GPA_PERF_BLOCK_RLCUSER_AMD: + return "VK_GPA_PERF_BLOCK_RLCUSER_AMD"; + default: + return "Unhandled VkGpaPerfBlockAMD"; + } +} +static inline const char* string_VkGpaSampleTypeAMD(VkGpaSampleTypeAMD input_value) { + switch (input_value) { + case VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD: + return "VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD"; + case VK_GPA_SAMPLE_TYPE_TRACE_AMD: + return "VK_GPA_SAMPLE_TYPE_TRACE_AMD"; + case VK_GPA_SAMPLE_TYPE_TIMING_AMD: + return "VK_GPA_SAMPLE_TYPE_TIMING_AMD"; + default: + return "Unhandled VkGpaSampleTypeAMD"; + } +} +static inline const char* string_VkGpaDeviceClockModeAMD(VkGpaDeviceClockModeAMD input_value) { + switch (input_value) { + case VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD"; + case VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD"; + case VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD"; + case VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD"; + case VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD"; + case VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD: + return "VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD"; + default: + return "Unhandled VkGpaDeviceClockModeAMD"; + } +} static inline const char* string_VkDescriptorMappingSourceEXT(VkDescriptorMappingSourceEXT input_value) { switch (input_value) { case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT: @@ -5072,6 +5296,8 @@ static inline const char* string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value case VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX: return "VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX"; #endif // VK_ENABLE_BETA_EXTENSIONS + case VK_GEOMETRY_TYPE_MICROMAP_KHR: + return "VK_GEOMETRY_TYPE_MICROMAP_KHR"; default: return "Unhandled VkGeometryTypeKHR"; } @@ -5408,32 +5634,6 @@ static inline const char* string_VkCopyMicromapModeEXT(VkCopyMicromapModeEXT inp return "Unhandled VkCopyMicromapModeEXT"; } } -static inline const char* string_VkOpacityMicromapFormatEXT(VkOpacityMicromapFormatEXT input_value) { - switch (input_value) { - case VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: - return "VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT"; - case VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: - return "VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT"; - default: - return "Unhandled VkOpacityMicromapFormatEXT"; - } -} -static inline const char* string_VkOpacityMicromapSpecialIndexEXT(VkOpacityMicromapSpecialIndexEXT input_value) { - switch (input_value) { - case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: - return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT"; - case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: - return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT"; - case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: - return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT"; - case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: - return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT"; - case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: - return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV"; - default: - return "Unhandled VkOpacityMicromapSpecialIndexEXT"; - } -} static inline const char* string_VkAccelerationStructureCompatibilityKHR(VkAccelerationStructureCompatibilityKHR input_value) { switch (input_value) { case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: @@ -7362,12 +7562,12 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi return "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; case VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: return "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; - case VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: - return "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: return "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; #endif // VK_ENABLE_BETA_EXTENSIONS + case VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR: + return "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR"; default: return "Unhandled VkPipelineCreateFlagBits"; } @@ -8502,6 +8702,7 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"; + if (input_value == VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM) return "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM"; if (input_value == VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV) return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM"; @@ -8653,6 +8854,8 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) { if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; #endif // VK_ENABLE_BETA_EXTENSIONS if (input_value == VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT) return "VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; @@ -8666,8 +8869,6 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) { if (input_value == VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS if (input_value == VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX) return "VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX"; #endif // VK_ENABLE_BETA_EXTENSIONS @@ -8752,7 +8953,6 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value) if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; if (input_value == VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -8764,6 +8964,8 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value) if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; if (input_value == VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) return "VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR"; if (input_value == VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT) return "VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT"; return "Unhandled VkPipelineCreateFlagBits2"; } @@ -10443,6 +10645,43 @@ static inline std::string string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMes return ret; } #endif // __cplusplus +static inline const char* string_VkGpaSqShaderStageFlagBitsAMD(VkGpaSqShaderStageFlagBitsAMD input_value) { + switch (input_value) { + case VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD"; + case VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD: + return "VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD"; + default: + return "Unhandled VkGpaSqShaderStageFlagBitsAMD"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkGpaSqShaderStageFlagsAMD(VkGpaSqShaderStageFlagsAMD input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkGpaSqShaderStageFlagBitsAMD(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkGpaSqShaderStageFlagsAMD(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkTensorViewCreateFlagBitsARM(uint64_t input_value) { if (input_value == VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) return "VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM"; return "Unhandled VkTensorViewCreateFlagBitsARM"; @@ -10545,10 +10784,10 @@ static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanc return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"; case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"; - case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: - return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT"; - case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: - return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; + case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR: + return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR"; + case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR: + return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR"; default: return "Unhandled VkGeometryInstanceFlagBitsKHR"; } @@ -10584,10 +10823,6 @@ static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuild return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"; case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV"; - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT"; - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -10598,6 +10833,12 @@ static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuild return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR"; case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR"; + case VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR: + return "VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR"; default: return "Unhandled VkBuildAccelerationStructureFlagBitsKHR"; } @@ -11454,6 +11695,8 @@ static inline const char* string_VkShaderCreateFlagBitsEXT(VkShaderCreateFlagBit return "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: return "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; + case VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT: + return "VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT"; case VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT: return "VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT"; case VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR: @@ -12966,6 +13209,14 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkPhysicalDeviceRobustness2PropertiesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: return "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: + return "VkAccelerationStructureGeometryMicromapDataKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + return "VkPhysicalDeviceOpacityMicromapFeaturesKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + return "VkPhysicalDeviceOpacityMicromapPropertiesKHR"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: + return "VkAccelerationStructureTrianglesOpacityMicromapKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: return "VkPhysicalDeviceMaintenance10FeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: @@ -13120,6 +13371,20 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: return "VkAndroidHardwareBufferFormatProperties2ANDROID"; #endif // VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + return "VkPhysicalDeviceGpaFeaturesAMD"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + return "VkPhysicalDeviceGpaPropertiesAMD"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + return "VkPhysicalDeviceGpaProperties2AMD"; + case VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD: + return "VkGpaSampleBeginInfoAMD"; + case VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD: + return "VkGpaDeviceClockModeInfoAMD"; + case VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD: + return "VkGpaDeviceGetClockInfoAMD"; + case VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD: + return "VkGpaSessionCreateInfoAMD"; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: return "VkPhysicalDeviceShaderEnqueueFeaturesAMDX"; @@ -13248,6 +13513,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkFilterCubicImageViewImageFormatPropertiesEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: return "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + return "VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM"; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: return "VkImportMemoryHostPointerInfoEXT"; case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: @@ -13464,6 +13731,16 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkPhysicalDeviceQueuePerfHintFeaturesQCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: return "VkPhysicalDeviceQueuePerfHintPropertiesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + return "VkPhysicalDeviceImageProcessing3FeaturesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + return "VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + return "VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + return "VkPhysicalDeviceShaderSplitBarrierFeaturesEXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + return "VkPhysicalDeviceShaderSplitBarrierPropertiesEXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: return "VkCudaModuleCreateInfoNV"; diff --git a/scripts/known_good.json b/scripts/known_good.json index f661fd9..14b4df0 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.350" + "commit": "v1.4.351" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp index 6752c28..dec6322 100644 --- a/src/vulkan/vk_safe_struct_ext.cpp +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -8695,6 +8695,106 @@ void safe_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT::initialize( textureCompressionASTC_3D = copy_src->textureCompressionASTC_3D; pNext = SafePnextCopy(copy_src->pNext); } + +safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT( + const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderSplitBarrier(in_struct->shaderSplitBarrier) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT), pNext(nullptr), shaderSplitBarrier() {} + +safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT( + const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderSplitBarrier = copy_src.shaderSplitBarrier; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSplitBarrier = copy_src.shaderSplitBarrier; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::~safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::initialize(const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSplitBarrier = in_struct->shaderSplitBarrier; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSplitBarrier = copy_src->shaderSplitBarrier; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT( + const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), splitBarrierReservedSharedMemory(in_struct->splitBarrierReservedSharedMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT), + pNext(nullptr), + splitBarrierReservedSharedMemory() {} + +safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT( + const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& copy_src) { + sType = copy_src.sType; + splitBarrierReservedSharedMemory = copy_src.splitBarrierReservedSharedMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::operator=( + const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + splitBarrierReservedSharedMemory = copy_src.splitBarrierReservedSharedMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::~safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::initialize( + const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + splitBarrierReservedSharedMemory = in_struct->splitBarrierReservedSharedMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT::initialize( + const safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + splitBarrierReservedSharedMemory = copy_src->splitBarrierReservedSharedMemory; + pNext = SafePnextCopy(copy_src->pNext); +} #ifdef VK_USE_PLATFORM_METAL_EXT safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct, diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp index 76a3ef0..ebb12fe 100644 --- a/src/vulkan/vk_safe_struct_khr.cpp +++ b/src/vulkan/vk_safe_struct_khr.cpp @@ -18967,6 +18967,372 @@ void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkAccelerationStructureGeometryMicromapDataKHR::safe_VkAccelerationStructureGeometryMicromapDataKHR( + const VkAccelerationStructureGeometryMicromapDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + usageCountsCount(in_struct->usageCountsCount), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + data(in_struct->data), + triangleArray(in_struct->triangleArray), + triangleArrayStride(in_struct->triangleArrayStride) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageKHR[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageKHR) * in_struct->usageCountsCount); + } + + if (in_struct->ppUsageCounts) { + VkMicromapUsageKHR** pointer_array = new VkMicromapUsageKHR*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageKHR(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureGeometryMicromapDataKHR::safe_VkAccelerationStructureGeometryMicromapDataKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR), + pNext(nullptr), + usageCountsCount(), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + data(), + triangleArray(), + triangleArrayStride() {} + +safe_VkAccelerationStructureGeometryMicromapDataKHR::safe_VkAccelerationStructureGeometryMicromapDataKHR( + const safe_VkAccelerationStructureGeometryMicromapDataKHR& copy_src) { + sType = copy_src.sType; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data = copy_src.data; + triangleArray = copy_src.triangleArray; + triangleArrayStride = copy_src.triangleArrayStride; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageKHR[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageKHR) * copy_src.usageCountsCount); + } + + if (copy_src.ppUsageCounts) { + VkMicromapUsageKHR** pointer_array = new VkMicromapUsageKHR*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageKHR(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureGeometryMicromapDataKHR& safe_VkAccelerationStructureGeometryMicromapDataKHR::operator=( + const safe_VkAccelerationStructureGeometryMicromapDataKHR& copy_src) { + if (©_src == this) return *this; + + if (pUsageCounts) delete[] pUsageCounts; + + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data = copy_src.data; + triangleArray = copy_src.triangleArray; + triangleArrayStride = copy_src.triangleArrayStride; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageKHR[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageKHR) * copy_src.usageCountsCount); + } + + if (copy_src.ppUsageCounts) { + VkMicromapUsageKHR** pointer_array = new VkMicromapUsageKHR*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageKHR(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } + + return *this; +} + +safe_VkAccelerationStructureGeometryMicromapDataKHR::~safe_VkAccelerationStructureGeometryMicromapDataKHR() { + if (pUsageCounts) delete[] pUsageCounts; + + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureGeometryMicromapDataKHR::initialize( + const VkAccelerationStructureGeometryMicromapDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pUsageCounts) delete[] pUsageCounts; + + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + sType = in_struct->sType; + usageCountsCount = in_struct->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data = in_struct->data; + triangleArray = in_struct->triangleArray; + triangleArrayStride = in_struct->triangleArrayStride; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageKHR[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageKHR) * in_struct->usageCountsCount); + } + + if (in_struct->ppUsageCounts) { + VkMicromapUsageKHR** pointer_array = new VkMicromapUsageKHR*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageKHR(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +void safe_VkAccelerationStructureGeometryMicromapDataKHR::initialize( + const safe_VkAccelerationStructureGeometryMicromapDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usageCountsCount = copy_src->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data = copy_src->data; + triangleArray = copy_src->triangleArray; + triangleArrayStride = copy_src->triangleArrayStride; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pUsageCounts) { + pUsageCounts = new VkMicromapUsageKHR[copy_src->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageKHR) * copy_src->usageCountsCount); + } + + if (copy_src->ppUsageCounts) { + VkMicromapUsageKHR** pointer_array = new VkMicromapUsageKHR*[copy_src->usageCountsCount]; + for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageKHR(*copy_src->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR( + const VkPhysicalDeviceOpacityMicromapFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), micromap(in_struct->micromap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR), pNext(nullptr), micromap() {} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR( + const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& copy_src) { + sType = copy_src.sType; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::operator=( + const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::~safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::initialize(const VkPhysicalDeviceOpacityMicromapFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + micromap = in_struct->micromap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR::initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + micromap = copy_src->micromap; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR( + const VkPhysicalDeviceOpacityMicromapPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxOpacity2StateSubdivisionLevel(in_struct->maxOpacity2StateSubdivisionLevel), + maxOpacity4StateSubdivisionLevel(in_struct->maxOpacity4StateSubdivisionLevel), + maxOpacityLossy4StateSubdivisionLevel(in_struct->maxOpacityLossy4StateSubdivisionLevel), + maxMicromapTriangles(in_struct->maxMicromapTriangles) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR), + pNext(nullptr), + maxOpacity2StateSubdivisionLevel(), + maxOpacity4StateSubdivisionLevel(), + maxOpacityLossy4StateSubdivisionLevel(), + maxMicromapTriangles() {} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& copy_src) { + sType = copy_src.sType; + maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel; + maxOpacityLossy4StateSubdivisionLevel = copy_src.maxOpacityLossy4StateSubdivisionLevel; + maxMicromapTriangles = copy_src.maxMicromapTriangles; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::operator=( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel; + maxOpacityLossy4StateSubdivisionLevel = copy_src.maxOpacityLossy4StateSubdivisionLevel; + maxMicromapTriangles = copy_src.maxMicromapTriangles; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::~safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::initialize(const VkPhysicalDeviceOpacityMicromapPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxOpacity2StateSubdivisionLevel = in_struct->maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = in_struct->maxOpacity4StateSubdivisionLevel; + maxOpacityLossy4StateSubdivisionLevel = in_struct->maxOpacityLossy4StateSubdivisionLevel; + maxMicromapTriangles = in_struct->maxMicromapTriangles; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR::initialize( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxOpacity2StateSubdivisionLevel = copy_src->maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src->maxOpacity4StateSubdivisionLevel; + maxOpacityLossy4StateSubdivisionLevel = copy_src->maxOpacityLossy4StateSubdivisionLevel; + maxMicromapTriangles = copy_src->maxMicromapTriangles; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::safe_VkAccelerationStructureTrianglesOpacityMicromapKHR( + const VkAccelerationStructureTrianglesOpacityMicromapKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + indexType(in_struct->indexType), + indexBuffer(in_struct->indexBuffer), + indexStride(in_struct->indexStride), + baseTriangle(in_struct->baseTriangle), + micromap(in_struct->micromap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::safe_VkAccelerationStructureTrianglesOpacityMicromapKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR), + pNext(nullptr), + indexType(), + indexBuffer(), + indexStride(), + baseTriangle(), + micromap() {} + +safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::safe_VkAccelerationStructureTrianglesOpacityMicromapKHR( + const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& copy_src) { + sType = copy_src.sType; + indexType = copy_src.indexType; + indexBuffer = copy_src.indexBuffer; + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::operator=( + const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indexType = copy_src.indexType; + indexBuffer = copy_src.indexBuffer; + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::~safe_VkAccelerationStructureTrianglesOpacityMicromapKHR() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::initialize( + const VkAccelerationStructureTrianglesOpacityMicromapKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indexType = in_struct->indexType; + indexBuffer = in_struct->indexBuffer; + indexStride = in_struct->indexStride; + baseTriangle = in_struct->baseTriangle; + micromap = in_struct->micromap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureTrianglesOpacityMicromapKHR::initialize( + const safe_VkAccelerationStructureTrianglesOpacityMicromapKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indexType = copy_src->indexType; + indexBuffer = copy_src->indexBuffer; + indexStride = copy_src->indexStride; + baseTriangle = copy_src->baseTriangle; + micromap = copy_src->micromap; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceMaintenance10FeaturesKHR::safe_VkPhysicalDeviceMaintenance10FeaturesKHR( const VkPhysicalDeviceMaintenance10FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), maintenance10(in_struct->maintenance10) { diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index a93181f..492cdcd 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -1040,6 +1040,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: + safe_pNext = new safe_VkAccelerationStructureGeometryMicromapDataKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: + safe_pNext = new safe_VkAccelerationStructureTrianglesOpacityMicromapKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceMaintenance10FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -1185,6 +1197,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { safe_pNext = new safe_VkAndroidHardwareBufferFormatProperties2ANDROID(reinterpret_cast(pNext), copy_state, false); break; #endif // VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + safe_pNext = new safe_VkPhysicalDeviceGpaFeaturesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + safe_pNext = new safe_VkPhysicalDeviceGpaPropertiesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + safe_pNext = new safe_VkPhysicalDeviceGpaProperties2AMD(reinterpret_cast(pNext), copy_state, false); + break; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: safe_pNext = new safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(reinterpret_cast(pNext), copy_state, false); @@ -1316,6 +1337,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: safe_pNext = new safe_VkImportMemoryHostPointerInfoEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -1551,6 +1575,21 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: safe_pNext = new safe_VkPhysicalDeviceQueuePerfHintPropertiesQCOM(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(reinterpret_cast(pNext), copy_state, false); @@ -3493,6 +3532,18 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -3638,6 +3689,15 @@ void FreePnextChain(const void *pNext) { delete reinterpret_cast(header); break; #endif // VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + delete reinterpret_cast(header); + break; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: delete reinterpret_cast(header); @@ -3769,6 +3829,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: delete reinterpret_cast(header); break; @@ -4004,6 +4067,21 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; #ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: delete reinterpret_cast(header); diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp index b2149c0..a87116d 100644 --- a/src/vulkan/vk_safe_struct_vendor.cpp +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -2233,6 +2233,559 @@ void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize( pNext = SafePnextCopy(copy_src->pNext); } #endif // VK_USE_PLATFORM_ANDROID_KHR + +safe_VkPhysicalDeviceGpaFeaturesAMD::safe_VkPhysicalDeviceGpaFeaturesAMD(const VkPhysicalDeviceGpaFeaturesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + perfCounters(in_struct->perfCounters), + streamingPerfCounters(in_struct->streamingPerfCounters), + sqThreadTracing(in_struct->sqThreadTracing), + clockModes(in_struct->clockModes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceGpaFeaturesAMD::safe_VkPhysicalDeviceGpaFeaturesAMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD), + pNext(nullptr), + perfCounters(), + streamingPerfCounters(), + sqThreadTracing(), + clockModes() {} + +safe_VkPhysicalDeviceGpaFeaturesAMD::safe_VkPhysicalDeviceGpaFeaturesAMD(const safe_VkPhysicalDeviceGpaFeaturesAMD& copy_src) { + sType = copy_src.sType; + perfCounters = copy_src.perfCounters; + streamingPerfCounters = copy_src.streamingPerfCounters; + sqThreadTracing = copy_src.sqThreadTracing; + clockModes = copy_src.clockModes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceGpaFeaturesAMD& safe_VkPhysicalDeviceGpaFeaturesAMD::operator=( + const safe_VkPhysicalDeviceGpaFeaturesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + perfCounters = copy_src.perfCounters; + streamingPerfCounters = copy_src.streamingPerfCounters; + sqThreadTracing = copy_src.sqThreadTracing; + clockModes = copy_src.clockModes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceGpaFeaturesAMD::~safe_VkPhysicalDeviceGpaFeaturesAMD() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceGpaFeaturesAMD::initialize(const VkPhysicalDeviceGpaFeaturesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + perfCounters = in_struct->perfCounters; + streamingPerfCounters = in_struct->streamingPerfCounters; + sqThreadTracing = in_struct->sqThreadTracing; + clockModes = in_struct->clockModes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceGpaFeaturesAMD::initialize(const safe_VkPhysicalDeviceGpaFeaturesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + perfCounters = copy_src->perfCounters; + streamingPerfCounters = copy_src->streamingPerfCounters; + sqThreadTracing = copy_src->sqThreadTracing; + clockModes = copy_src->clockModes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceGpaPropertiesAMD::safe_VkPhysicalDeviceGpaPropertiesAMD(const VkPhysicalDeviceGpaPropertiesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + maxSqttSeBufferSize(in_struct->maxSqttSeBufferSize), + shaderEngineCount(in_struct->shaderEngineCount), + perfBlockCount(in_struct->perfBlockCount), + pPerfBlocks(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPerfBlocks) { + pPerfBlocks = new VkGpaPerfBlockPropertiesAMD[in_struct->perfBlockCount]; + memcpy((void*)pPerfBlocks, (void*)in_struct->pPerfBlocks, sizeof(VkGpaPerfBlockPropertiesAMD) * in_struct->perfBlockCount); + } +} + +safe_VkPhysicalDeviceGpaPropertiesAMD::safe_VkPhysicalDeviceGpaPropertiesAMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD), + pNext(nullptr), + flags(), + maxSqttSeBufferSize(), + shaderEngineCount(), + perfBlockCount(), + pPerfBlocks(nullptr) {} + +safe_VkPhysicalDeviceGpaPropertiesAMD::safe_VkPhysicalDeviceGpaPropertiesAMD( + const safe_VkPhysicalDeviceGpaPropertiesAMD& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + maxSqttSeBufferSize = copy_src.maxSqttSeBufferSize; + shaderEngineCount = copy_src.shaderEngineCount; + perfBlockCount = copy_src.perfBlockCount; + pPerfBlocks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerfBlocks) { + pPerfBlocks = new VkGpaPerfBlockPropertiesAMD[copy_src.perfBlockCount]; + memcpy((void*)pPerfBlocks, (void*)copy_src.pPerfBlocks, sizeof(VkGpaPerfBlockPropertiesAMD) * copy_src.perfBlockCount); + } +} + +safe_VkPhysicalDeviceGpaPropertiesAMD& safe_VkPhysicalDeviceGpaPropertiesAMD::operator=( + const safe_VkPhysicalDeviceGpaPropertiesAMD& copy_src) { + if (©_src == this) return *this; + + if (pPerfBlocks) delete[] pPerfBlocks; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + maxSqttSeBufferSize = copy_src.maxSqttSeBufferSize; + shaderEngineCount = copy_src.shaderEngineCount; + perfBlockCount = copy_src.perfBlockCount; + pPerfBlocks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerfBlocks) { + pPerfBlocks = new VkGpaPerfBlockPropertiesAMD[copy_src.perfBlockCount]; + memcpy((void*)pPerfBlocks, (void*)copy_src.pPerfBlocks, sizeof(VkGpaPerfBlockPropertiesAMD) * copy_src.perfBlockCount); + } + + return *this; +} + +safe_VkPhysicalDeviceGpaPropertiesAMD::~safe_VkPhysicalDeviceGpaPropertiesAMD() { + if (pPerfBlocks) delete[] pPerfBlocks; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceGpaPropertiesAMD::initialize(const VkPhysicalDeviceGpaPropertiesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPerfBlocks) delete[] pPerfBlocks; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + maxSqttSeBufferSize = in_struct->maxSqttSeBufferSize; + shaderEngineCount = in_struct->shaderEngineCount; + perfBlockCount = in_struct->perfBlockCount; + pPerfBlocks = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPerfBlocks) { + pPerfBlocks = new VkGpaPerfBlockPropertiesAMD[in_struct->perfBlockCount]; + memcpy((void*)pPerfBlocks, (void*)in_struct->pPerfBlocks, sizeof(VkGpaPerfBlockPropertiesAMD) * in_struct->perfBlockCount); + } +} + +void safe_VkPhysicalDeviceGpaPropertiesAMD::initialize(const safe_VkPhysicalDeviceGpaPropertiesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + maxSqttSeBufferSize = copy_src->maxSqttSeBufferSize; + shaderEngineCount = copy_src->shaderEngineCount; + perfBlockCount = copy_src->perfBlockCount; + pPerfBlocks = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPerfBlocks) { + pPerfBlocks = new VkGpaPerfBlockPropertiesAMD[copy_src->perfBlockCount]; + memcpy((void*)pPerfBlocks, (void*)copy_src->pPerfBlocks, sizeof(VkGpaPerfBlockPropertiesAMD) * copy_src->perfBlockCount); + } +} + +safe_VkPhysicalDeviceGpaProperties2AMD::safe_VkPhysicalDeviceGpaProperties2AMD(const VkPhysicalDeviceGpaProperties2AMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), revisionId(in_struct->revisionId) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceGpaProperties2AMD::safe_VkPhysicalDeviceGpaProperties2AMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD), pNext(nullptr), revisionId() {} + +safe_VkPhysicalDeviceGpaProperties2AMD::safe_VkPhysicalDeviceGpaProperties2AMD( + const safe_VkPhysicalDeviceGpaProperties2AMD& copy_src) { + sType = copy_src.sType; + revisionId = copy_src.revisionId; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceGpaProperties2AMD& safe_VkPhysicalDeviceGpaProperties2AMD::operator=( + const safe_VkPhysicalDeviceGpaProperties2AMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + revisionId = copy_src.revisionId; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceGpaProperties2AMD::~safe_VkPhysicalDeviceGpaProperties2AMD() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceGpaProperties2AMD::initialize(const VkPhysicalDeviceGpaProperties2AMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + revisionId = in_struct->revisionId; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceGpaProperties2AMD::initialize(const safe_VkPhysicalDeviceGpaProperties2AMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + revisionId = copy_src->revisionId; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGpaSampleBeginInfoAMD::safe_VkGpaSampleBeginInfoAMD(const VkGpaSampleBeginInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + sampleType(in_struct->sampleType), + sampleInternalOperations(in_struct->sampleInternalOperations), + cacheFlushOnCounterCollection(in_struct->cacheFlushOnCounterCollection), + sqShaderMaskEnable(in_struct->sqShaderMaskEnable), + sqShaderMask(in_struct->sqShaderMask), + perfCounterCount(in_struct->perfCounterCount), + pPerfCounters(nullptr), + streamingPerfTraceSampleInterval(in_struct->streamingPerfTraceSampleInterval), + perfCounterDeviceMemoryLimit(in_struct->perfCounterDeviceMemoryLimit), + sqThreadTraceEnable(in_struct->sqThreadTraceEnable), + sqThreadTraceSuppressInstructionTokens(in_struct->sqThreadTraceSuppressInstructionTokens), + sqThreadTraceDeviceMemoryLimit(in_struct->sqThreadTraceDeviceMemoryLimit), + timingPreSample(in_struct->timingPreSample), + timingPostSample(in_struct->timingPostSample) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPerfCounters) { + pPerfCounters = new VkGpaPerfCounterAMD[in_struct->perfCounterCount]; + memcpy((void*)pPerfCounters, (void*)in_struct->pPerfCounters, sizeof(VkGpaPerfCounterAMD) * in_struct->perfCounterCount); + } +} + +safe_VkGpaSampleBeginInfoAMD::safe_VkGpaSampleBeginInfoAMD() + : sType(VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD), + pNext(nullptr), + sampleType(), + sampleInternalOperations(), + cacheFlushOnCounterCollection(), + sqShaderMaskEnable(), + sqShaderMask(), + perfCounterCount(), + pPerfCounters(nullptr), + streamingPerfTraceSampleInterval(), + perfCounterDeviceMemoryLimit(), + sqThreadTraceEnable(), + sqThreadTraceSuppressInstructionTokens(), + sqThreadTraceDeviceMemoryLimit(), + timingPreSample(), + timingPostSample() {} + +safe_VkGpaSampleBeginInfoAMD::safe_VkGpaSampleBeginInfoAMD(const safe_VkGpaSampleBeginInfoAMD& copy_src) { + sType = copy_src.sType; + sampleType = copy_src.sampleType; + sampleInternalOperations = copy_src.sampleInternalOperations; + cacheFlushOnCounterCollection = copy_src.cacheFlushOnCounterCollection; + sqShaderMaskEnable = copy_src.sqShaderMaskEnable; + sqShaderMask = copy_src.sqShaderMask; + perfCounterCount = copy_src.perfCounterCount; + pPerfCounters = nullptr; + streamingPerfTraceSampleInterval = copy_src.streamingPerfTraceSampleInterval; + perfCounterDeviceMemoryLimit = copy_src.perfCounterDeviceMemoryLimit; + sqThreadTraceEnable = copy_src.sqThreadTraceEnable; + sqThreadTraceSuppressInstructionTokens = copy_src.sqThreadTraceSuppressInstructionTokens; + sqThreadTraceDeviceMemoryLimit = copy_src.sqThreadTraceDeviceMemoryLimit; + timingPreSample = copy_src.timingPreSample; + timingPostSample = copy_src.timingPostSample; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerfCounters) { + pPerfCounters = new VkGpaPerfCounterAMD[copy_src.perfCounterCount]; + memcpy((void*)pPerfCounters, (void*)copy_src.pPerfCounters, sizeof(VkGpaPerfCounterAMD) * copy_src.perfCounterCount); + } +} + +safe_VkGpaSampleBeginInfoAMD& safe_VkGpaSampleBeginInfoAMD::operator=(const safe_VkGpaSampleBeginInfoAMD& copy_src) { + if (©_src == this) return *this; + + if (pPerfCounters) delete[] pPerfCounters; + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleType = copy_src.sampleType; + sampleInternalOperations = copy_src.sampleInternalOperations; + cacheFlushOnCounterCollection = copy_src.cacheFlushOnCounterCollection; + sqShaderMaskEnable = copy_src.sqShaderMaskEnable; + sqShaderMask = copy_src.sqShaderMask; + perfCounterCount = copy_src.perfCounterCount; + pPerfCounters = nullptr; + streamingPerfTraceSampleInterval = copy_src.streamingPerfTraceSampleInterval; + perfCounterDeviceMemoryLimit = copy_src.perfCounterDeviceMemoryLimit; + sqThreadTraceEnable = copy_src.sqThreadTraceEnable; + sqThreadTraceSuppressInstructionTokens = copy_src.sqThreadTraceSuppressInstructionTokens; + sqThreadTraceDeviceMemoryLimit = copy_src.sqThreadTraceDeviceMemoryLimit; + timingPreSample = copy_src.timingPreSample; + timingPostSample = copy_src.timingPostSample; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerfCounters) { + pPerfCounters = new VkGpaPerfCounterAMD[copy_src.perfCounterCount]; + memcpy((void*)pPerfCounters, (void*)copy_src.pPerfCounters, sizeof(VkGpaPerfCounterAMD) * copy_src.perfCounterCount); + } + + return *this; +} + +safe_VkGpaSampleBeginInfoAMD::~safe_VkGpaSampleBeginInfoAMD() { + if (pPerfCounters) delete[] pPerfCounters; + FreePnextChain(pNext); +} + +void safe_VkGpaSampleBeginInfoAMD::initialize(const VkGpaSampleBeginInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPerfCounters) delete[] pPerfCounters; + FreePnextChain(pNext); + sType = in_struct->sType; + sampleType = in_struct->sampleType; + sampleInternalOperations = in_struct->sampleInternalOperations; + cacheFlushOnCounterCollection = in_struct->cacheFlushOnCounterCollection; + sqShaderMaskEnable = in_struct->sqShaderMaskEnable; + sqShaderMask = in_struct->sqShaderMask; + perfCounterCount = in_struct->perfCounterCount; + pPerfCounters = nullptr; + streamingPerfTraceSampleInterval = in_struct->streamingPerfTraceSampleInterval; + perfCounterDeviceMemoryLimit = in_struct->perfCounterDeviceMemoryLimit; + sqThreadTraceEnable = in_struct->sqThreadTraceEnable; + sqThreadTraceSuppressInstructionTokens = in_struct->sqThreadTraceSuppressInstructionTokens; + sqThreadTraceDeviceMemoryLimit = in_struct->sqThreadTraceDeviceMemoryLimit; + timingPreSample = in_struct->timingPreSample; + timingPostSample = in_struct->timingPostSample; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPerfCounters) { + pPerfCounters = new VkGpaPerfCounterAMD[in_struct->perfCounterCount]; + memcpy((void*)pPerfCounters, (void*)in_struct->pPerfCounters, sizeof(VkGpaPerfCounterAMD) * in_struct->perfCounterCount); + } +} + +void safe_VkGpaSampleBeginInfoAMD::initialize(const safe_VkGpaSampleBeginInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleType = copy_src->sampleType; + sampleInternalOperations = copy_src->sampleInternalOperations; + cacheFlushOnCounterCollection = copy_src->cacheFlushOnCounterCollection; + sqShaderMaskEnable = copy_src->sqShaderMaskEnable; + sqShaderMask = copy_src->sqShaderMask; + perfCounterCount = copy_src->perfCounterCount; + pPerfCounters = nullptr; + streamingPerfTraceSampleInterval = copy_src->streamingPerfTraceSampleInterval; + perfCounterDeviceMemoryLimit = copy_src->perfCounterDeviceMemoryLimit; + sqThreadTraceEnable = copy_src->sqThreadTraceEnable; + sqThreadTraceSuppressInstructionTokens = copy_src->sqThreadTraceSuppressInstructionTokens; + sqThreadTraceDeviceMemoryLimit = copy_src->sqThreadTraceDeviceMemoryLimit; + timingPreSample = copy_src->timingPreSample; + timingPostSample = copy_src->timingPostSample; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPerfCounters) { + pPerfCounters = new VkGpaPerfCounterAMD[copy_src->perfCounterCount]; + memcpy((void*)pPerfCounters, (void*)copy_src->pPerfCounters, sizeof(VkGpaPerfCounterAMD) * copy_src->perfCounterCount); + } +} + +safe_VkGpaDeviceClockModeInfoAMD::safe_VkGpaDeviceClockModeInfoAMD(const VkGpaDeviceClockModeInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + clockMode(in_struct->clockMode), + memoryClockRatioToPeak(in_struct->memoryClockRatioToPeak), + engineClockRatioToPeak(in_struct->engineClockRatioToPeak) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGpaDeviceClockModeInfoAMD::safe_VkGpaDeviceClockModeInfoAMD() + : sType(VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD), + pNext(nullptr), + clockMode(), + memoryClockRatioToPeak(), + engineClockRatioToPeak() {} + +safe_VkGpaDeviceClockModeInfoAMD::safe_VkGpaDeviceClockModeInfoAMD(const safe_VkGpaDeviceClockModeInfoAMD& copy_src) { + sType = copy_src.sType; + clockMode = copy_src.clockMode; + memoryClockRatioToPeak = copy_src.memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src.engineClockRatioToPeak; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGpaDeviceClockModeInfoAMD& safe_VkGpaDeviceClockModeInfoAMD::operator=(const safe_VkGpaDeviceClockModeInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + clockMode = copy_src.clockMode; + memoryClockRatioToPeak = copy_src.memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src.engineClockRatioToPeak; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGpaDeviceClockModeInfoAMD::~safe_VkGpaDeviceClockModeInfoAMD() { FreePnextChain(pNext); } + +void safe_VkGpaDeviceClockModeInfoAMD::initialize(const VkGpaDeviceClockModeInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + clockMode = in_struct->clockMode; + memoryClockRatioToPeak = in_struct->memoryClockRatioToPeak; + engineClockRatioToPeak = in_struct->engineClockRatioToPeak; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGpaDeviceClockModeInfoAMD::initialize(const safe_VkGpaDeviceClockModeInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + clockMode = copy_src->clockMode; + memoryClockRatioToPeak = copy_src->memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src->engineClockRatioToPeak; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGpaDeviceGetClockInfoAMD::safe_VkGpaDeviceGetClockInfoAMD(const VkGpaDeviceGetClockInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + memoryClockRatioToPeak(in_struct->memoryClockRatioToPeak), + engineClockRatioToPeak(in_struct->engineClockRatioToPeak), + memoryClockFrequency(in_struct->memoryClockFrequency), + engineClockFrequency(in_struct->engineClockFrequency) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGpaDeviceGetClockInfoAMD::safe_VkGpaDeviceGetClockInfoAMD() + : sType(VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD), + pNext(nullptr), + memoryClockRatioToPeak(), + engineClockRatioToPeak(), + memoryClockFrequency(), + engineClockFrequency() {} + +safe_VkGpaDeviceGetClockInfoAMD::safe_VkGpaDeviceGetClockInfoAMD(const safe_VkGpaDeviceGetClockInfoAMD& copy_src) { + sType = copy_src.sType; + memoryClockRatioToPeak = copy_src.memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src.engineClockRatioToPeak; + memoryClockFrequency = copy_src.memoryClockFrequency; + engineClockFrequency = copy_src.engineClockFrequency; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGpaDeviceGetClockInfoAMD& safe_VkGpaDeviceGetClockInfoAMD::operator=(const safe_VkGpaDeviceGetClockInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryClockRatioToPeak = copy_src.memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src.engineClockRatioToPeak; + memoryClockFrequency = copy_src.memoryClockFrequency; + engineClockFrequency = copy_src.engineClockFrequency; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGpaDeviceGetClockInfoAMD::~safe_VkGpaDeviceGetClockInfoAMD() { FreePnextChain(pNext); } + +void safe_VkGpaDeviceGetClockInfoAMD::initialize(const VkGpaDeviceGetClockInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryClockRatioToPeak = in_struct->memoryClockRatioToPeak; + engineClockRatioToPeak = in_struct->engineClockRatioToPeak; + memoryClockFrequency = in_struct->memoryClockFrequency; + engineClockFrequency = in_struct->engineClockFrequency; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGpaDeviceGetClockInfoAMD::initialize(const safe_VkGpaDeviceGetClockInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryClockRatioToPeak = copy_src->memoryClockRatioToPeak; + engineClockRatioToPeak = copy_src->engineClockRatioToPeak; + memoryClockFrequency = copy_src->memoryClockFrequency; + engineClockFrequency = copy_src->engineClockFrequency; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGpaSessionCreateInfoAMD::safe_VkGpaSessionCreateInfoAMD(const VkGpaSessionCreateInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), secondaryCopySource(in_struct->secondaryCopySource) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGpaSessionCreateInfoAMD::safe_VkGpaSessionCreateInfoAMD() + : sType(VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD), pNext(nullptr), secondaryCopySource() {} + +safe_VkGpaSessionCreateInfoAMD::safe_VkGpaSessionCreateInfoAMD(const safe_VkGpaSessionCreateInfoAMD& copy_src) { + sType = copy_src.sType; + secondaryCopySource = copy_src.secondaryCopySource; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGpaSessionCreateInfoAMD& safe_VkGpaSessionCreateInfoAMD::operator=(const safe_VkGpaSessionCreateInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + secondaryCopySource = copy_src.secondaryCopySource; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGpaSessionCreateInfoAMD::~safe_VkGpaSessionCreateInfoAMD() { FreePnextChain(pNext); } + +void safe_VkGpaSessionCreateInfoAMD::initialize(const VkGpaSessionCreateInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + secondaryCopySource = in_struct->secondaryCopySource; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGpaSessionCreateInfoAMD::initialize(const safe_VkGpaSessionCreateInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + secondaryCopySource = copy_src->secondaryCopySource; + pNext = SafePnextCopy(copy_src->pNext); +} #ifdef VK_ENABLE_BETA_EXTENSIONS safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX( @@ -4813,6 +5366,54 @@ void safe_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM( + const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), elapsedTimerQuery(in_struct->elapsedTimerQuery) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM), pNext(nullptr), elapsedTimerQuery() {} + +safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM( + const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& copy_src) { + sType = copy_src.sType; + elapsedTimerQuery = copy_src.elapsedTimerQuery; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + elapsedTimerQuery = copy_src.elapsedTimerQuery; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::~safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::initialize(const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + elapsedTimerQuery = in_struct->elapsedTimerQuery; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::initialize( + const safe_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + elapsedTimerQuery = copy_src->elapsedTimerQuery; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD( const VkPipelineCompilerControlCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), compilerControlFlags(in_struct->compilerControlFlags) { @@ -8340,6 +8941,173 @@ void safe_VkPhysicalDeviceQueuePerfHintPropertiesQCOM::initialize(const safe_VkP supportedQueues = copy_src->supportedQueues; pNext = SafePnextCopy(copy_src->pNext); } + +safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM( + const VkPhysicalDeviceImageProcessing3FeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + imageGatherLinear(in_struct->imageGatherLinear), + imageGatherExtendedModes(in_struct->imageGatherExtendedModes), + blockMatchExtendedClampToEdge(in_struct->blockMatchExtendedClampToEdge) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM), + pNext(nullptr), + imageGatherLinear(), + imageGatherExtendedModes(), + blockMatchExtendedClampToEdge() {} + +safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM( + const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& copy_src) { + sType = copy_src.sType; + imageGatherLinear = copy_src.imageGatherLinear; + imageGatherExtendedModes = copy_src.imageGatherExtendedModes; + blockMatchExtendedClampToEdge = copy_src.blockMatchExtendedClampToEdge; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::operator=( + const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageGatherLinear = copy_src.imageGatherLinear; + imageGatherExtendedModes = copy_src.imageGatherExtendedModes; + blockMatchExtendedClampToEdge = copy_src.blockMatchExtendedClampToEdge; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::~safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::initialize(const VkPhysicalDeviceImageProcessing3FeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageGatherLinear = in_struct->imageGatherLinear; + imageGatherExtendedModes = in_struct->imageGatherExtendedModes; + blockMatchExtendedClampToEdge = in_struct->blockMatchExtendedClampToEdge; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM::initialize( + const safe_VkPhysicalDeviceImageProcessing3FeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageGatherLinear = copy_src->imageGatherLinear; + imageGatherExtendedModes = copy_src->imageGatherExtendedModes; + blockMatchExtendedClampToEdge = copy_src->blockMatchExtendedClampToEdge; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderMultipleWaitQueues(in_struct->shaderMultipleWaitQueues) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM), + pNext(nullptr), + shaderMultipleWaitQueues() {} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& copy_src) { + sType = copy_src.sType; + shaderMultipleWaitQueues = copy_src.shaderMultipleWaitQueues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderMultipleWaitQueues = copy_src.shaderMultipleWaitQueues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::~safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::initialize( + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderMultipleWaitQueues = in_struct->shaderMultipleWaitQueues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::initialize( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderMultipleWaitQueues = copy_src->shaderMultipleWaitQueues; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( + const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxShaderWaitQueues(in_struct->maxShaderWaitQueues) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM), pNext(nullptr), maxShaderWaitQueues() {} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& copy_src) { + sType = copy_src.sType; + maxShaderWaitQueues = copy_src.maxShaderWaitQueues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::operator=( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxShaderWaitQueues = copy_src.maxShaderWaitQueues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::~safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::initialize( + const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxShaderWaitQueues = in_struct->maxShaderWaitQueues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::initialize( + const safe_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxShaderWaitQueues = copy_src->maxShaderWaitQueues; + pNext = SafePnextCopy(copy_src->pNext); +} #ifdef VK_ENABLE_BETA_EXTENSIONS safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct,