build: Update to header 1.4.321
diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 0e28185..81a4181 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -492,6 +492,7 @@
PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR;
PFN_vkGetPipelineBinaryDataKHR GetPipelineBinaryDataKHR;
PFN_vkReleaseCapturedPipelineDataKHR ReleaseCapturedPipelineDataKHR;
+ PFN_vkReleaseSwapchainImagesKHR ReleaseSwapchainImagesKHR;
PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR;
PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR;
PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR;
@@ -1164,6 +1165,7 @@
table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR");
table->GetPipelineBinaryDataKHR = (PFN_vkGetPipelineBinaryDataKHR)gdpa(device, "vkGetPipelineBinaryDataKHR");
table->ReleaseCapturedPipelineDataKHR = (PFN_vkReleaseCapturedPipelineDataKHR)gdpa(device, "vkReleaseCapturedPipelineDataKHR");
+ table->ReleaseSwapchainImagesKHR = (PFN_vkReleaseSwapchainImagesKHR)gdpa(device, "vkReleaseSwapchainImagesKHR");
table->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR");
table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR");
table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 52cd1f3..8c8a41d 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8821,6 +8821,174 @@
VkPipelineBinaryHandlesInfoKHR* ptr() { return reinterpret_cast<VkPipelineBinaryHandlesInfoKHR*>(this); }
VkPipelineBinaryHandlesInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryHandlesInfoKHR const*>(this); }
};
+struct safe_VkSurfacePresentModeKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkPresentModeKHR presentMode;
+
+ safe_VkSurfacePresentModeKHR(const VkSurfacePresentModeKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkSurfacePresentModeKHR(const safe_VkSurfacePresentModeKHR& copy_src);
+ safe_VkSurfacePresentModeKHR& operator=(const safe_VkSurfacePresentModeKHR& copy_src);
+ safe_VkSurfacePresentModeKHR();
+ ~safe_VkSurfacePresentModeKHR();
+ void initialize(const VkSurfacePresentModeKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSurfacePresentModeKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSurfacePresentModeKHR* ptr() { return reinterpret_cast<VkSurfacePresentModeKHR*>(this); }
+ VkSurfacePresentModeKHR const* ptr() const { return reinterpret_cast<VkSurfacePresentModeKHR const*>(this); }
+};
+struct safe_VkSurfacePresentScalingCapabilitiesKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkPresentScalingFlagsKHR supportedPresentScaling;
+ VkPresentGravityFlagsKHR supportedPresentGravityX;
+ VkPresentGravityFlagsKHR supportedPresentGravityY;
+ VkExtent2D minScaledImageExtent;
+ VkExtent2D maxScaledImageExtent;
+
+ safe_VkSurfacePresentScalingCapabilitiesKHR(const VkSurfacePresentScalingCapabilitiesKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkSurfacePresentScalingCapabilitiesKHR(const safe_VkSurfacePresentScalingCapabilitiesKHR& copy_src);
+ safe_VkSurfacePresentScalingCapabilitiesKHR& operator=(const safe_VkSurfacePresentScalingCapabilitiesKHR& copy_src);
+ safe_VkSurfacePresentScalingCapabilitiesKHR();
+ ~safe_VkSurfacePresentScalingCapabilitiesKHR();
+ void initialize(const VkSurfacePresentScalingCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSurfacePresentScalingCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSurfacePresentScalingCapabilitiesKHR* ptr() { return reinterpret_cast<VkSurfacePresentScalingCapabilitiesKHR*>(this); }
+ VkSurfacePresentScalingCapabilitiesKHR const* ptr() const {
+ return reinterpret_cast<VkSurfacePresentScalingCapabilitiesKHR const*>(this);
+ }
+};
+struct safe_VkSurfacePresentModeCompatibilityKHR {
+ VkStructureType sType;
+ void* pNext{};
+ uint32_t presentModeCount;
+ VkPresentModeKHR* pPresentModes{};
+
+ safe_VkSurfacePresentModeCompatibilityKHR(const VkSurfacePresentModeCompatibilityKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkSurfacePresentModeCompatibilityKHR(const safe_VkSurfacePresentModeCompatibilityKHR& copy_src);
+ safe_VkSurfacePresentModeCompatibilityKHR& operator=(const safe_VkSurfacePresentModeCompatibilityKHR& copy_src);
+ safe_VkSurfacePresentModeCompatibilityKHR();
+ ~safe_VkSurfacePresentModeCompatibilityKHR();
+ void initialize(const VkSurfacePresentModeCompatibilityKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSurfacePresentModeCompatibilityKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSurfacePresentModeCompatibilityKHR* ptr() { return reinterpret_cast<VkSurfacePresentModeCompatibilityKHR*>(this); }
+ VkSurfacePresentModeCompatibilityKHR const* ptr() const {
+ return reinterpret_cast<VkSurfacePresentModeCompatibilityKHR const*>(this);
+ }
+};
+struct safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkBool32 swapchainMaintenance1;
+
+ safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& copy_src);
+ safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& operator=(
+ const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& copy_src);
+ safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR();
+ ~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR();
+ void initialize(const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+ VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* ptr() {
+ return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(this);
+ }
+ VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const* ptr() const {
+ return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const*>(this);
+ }
+};
+struct safe_VkSwapchainPresentFenceInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ uint32_t swapchainCount;
+ VkFence* pFences{};
+
+ safe_VkSwapchainPresentFenceInfoKHR(const VkSwapchainPresentFenceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkSwapchainPresentFenceInfoKHR(const safe_VkSwapchainPresentFenceInfoKHR& copy_src);
+ safe_VkSwapchainPresentFenceInfoKHR& operator=(const safe_VkSwapchainPresentFenceInfoKHR& copy_src);
+ safe_VkSwapchainPresentFenceInfoKHR();
+ ~safe_VkSwapchainPresentFenceInfoKHR();
+ void initialize(const VkSwapchainPresentFenceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSwapchainPresentFenceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSwapchainPresentFenceInfoKHR* ptr() { return reinterpret_cast<VkSwapchainPresentFenceInfoKHR*>(this); }
+ VkSwapchainPresentFenceInfoKHR const* ptr() const { return reinterpret_cast<VkSwapchainPresentFenceInfoKHR const*>(this); }
+};
+struct safe_VkSwapchainPresentModesCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ uint32_t presentModeCount;
+ const VkPresentModeKHR* pPresentModes{};
+
+ safe_VkSwapchainPresentModesCreateInfoKHR(const VkSwapchainPresentModesCreateInfoKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkSwapchainPresentModesCreateInfoKHR(const safe_VkSwapchainPresentModesCreateInfoKHR& copy_src);
+ safe_VkSwapchainPresentModesCreateInfoKHR& operator=(const safe_VkSwapchainPresentModesCreateInfoKHR& copy_src);
+ safe_VkSwapchainPresentModesCreateInfoKHR();
+ ~safe_VkSwapchainPresentModesCreateInfoKHR();
+ void initialize(const VkSwapchainPresentModesCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSwapchainPresentModesCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSwapchainPresentModesCreateInfoKHR* ptr() { return reinterpret_cast<VkSwapchainPresentModesCreateInfoKHR*>(this); }
+ VkSwapchainPresentModesCreateInfoKHR const* ptr() const {
+ return reinterpret_cast<VkSwapchainPresentModesCreateInfoKHR const*>(this);
+ }
+};
+struct safe_VkSwapchainPresentModeInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ uint32_t swapchainCount;
+ const VkPresentModeKHR* pPresentModes{};
+
+ safe_VkSwapchainPresentModeInfoKHR(const VkSwapchainPresentModeInfoKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkSwapchainPresentModeInfoKHR(const safe_VkSwapchainPresentModeInfoKHR& copy_src);
+ safe_VkSwapchainPresentModeInfoKHR& operator=(const safe_VkSwapchainPresentModeInfoKHR& copy_src);
+ safe_VkSwapchainPresentModeInfoKHR();
+ ~safe_VkSwapchainPresentModeInfoKHR();
+ void initialize(const VkSwapchainPresentModeInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSwapchainPresentModeInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSwapchainPresentModeInfoKHR* ptr() { return reinterpret_cast<VkSwapchainPresentModeInfoKHR*>(this); }
+ VkSwapchainPresentModeInfoKHR const* ptr() const { return reinterpret_cast<VkSwapchainPresentModeInfoKHR const*>(this); }
+};
+struct safe_VkSwapchainPresentScalingCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ VkPresentScalingFlagsKHR scalingBehavior;
+ VkPresentGravityFlagsKHR presentGravityX;
+ VkPresentGravityFlagsKHR presentGravityY;
+
+ safe_VkSwapchainPresentScalingCreateInfoKHR(const VkSwapchainPresentScalingCreateInfoKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkSwapchainPresentScalingCreateInfoKHR(const safe_VkSwapchainPresentScalingCreateInfoKHR& copy_src);
+ safe_VkSwapchainPresentScalingCreateInfoKHR& operator=(const safe_VkSwapchainPresentScalingCreateInfoKHR& copy_src);
+ safe_VkSwapchainPresentScalingCreateInfoKHR();
+ ~safe_VkSwapchainPresentScalingCreateInfoKHR();
+ void initialize(const VkSwapchainPresentScalingCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkSwapchainPresentScalingCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkSwapchainPresentScalingCreateInfoKHR* ptr() { return reinterpret_cast<VkSwapchainPresentScalingCreateInfoKHR*>(this); }
+ VkSwapchainPresentScalingCreateInfoKHR const* ptr() const {
+ return reinterpret_cast<VkSwapchainPresentScalingCreateInfoKHR const*>(this);
+ }
+};
+struct safe_VkReleaseSwapchainImagesInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ VkSwapchainKHR swapchain;
+ uint32_t imageIndexCount;
+ const uint32_t* pImageIndices{};
+
+ safe_VkReleaseSwapchainImagesInfoKHR(const VkReleaseSwapchainImagesInfoKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkReleaseSwapchainImagesInfoKHR(const safe_VkReleaseSwapchainImagesInfoKHR& copy_src);
+ safe_VkReleaseSwapchainImagesInfoKHR& operator=(const safe_VkReleaseSwapchainImagesInfoKHR& copy_src);
+ safe_VkReleaseSwapchainImagesInfoKHR();
+ ~safe_VkReleaseSwapchainImagesInfoKHR();
+ void initialize(const VkReleaseSwapchainImagesInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkReleaseSwapchainImagesInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkReleaseSwapchainImagesInfoKHR* ptr() { return reinterpret_cast<VkReleaseSwapchainImagesInfoKHR*>(this); }
+ VkReleaseSwapchainImagesInfoKHR const* ptr() const { return reinterpret_cast<VkReleaseSwapchainImagesInfoKHR const*>(this); }
+};
struct safe_VkCooperativeMatrixPropertiesKHR {
VkStructureType sType;
void* pNext{};
@@ -9484,6 +9652,106 @@
return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
}
};
+struct safe_VkVideoEncodeIntraRefreshCapabilitiesKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes;
+ uint32_t maxIntraRefreshCycleDuration;
+ uint32_t maxIntraRefreshActiveReferencePictures;
+ VkBool32 partitionIndependentIntraRefreshRegions;
+ VkBool32 nonRectangularIntraRefreshRegions;
+
+ safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(const VkVideoEncodeIntraRefreshCapabilitiesKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& copy_src);
+ safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& operator=(const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& copy_src);
+ safe_VkVideoEncodeIntraRefreshCapabilitiesKHR();
+ ~safe_VkVideoEncodeIntraRefreshCapabilitiesKHR();
+ void initialize(const VkVideoEncodeIntraRefreshCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeIntraRefreshCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeIntraRefreshCapabilitiesKHR*>(this); }
+ VkVideoEncodeIntraRefreshCapabilitiesKHR const* ptr() const {
+ return reinterpret_cast<VkVideoEncodeIntraRefreshCapabilitiesKHR const*>(this);
+ }
+};
+struct safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode;
+
+ safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(const VkVideoEncodeSessionIntraRefreshCreateInfoKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& copy_src);
+ safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& operator=(
+ const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& copy_src);
+ safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR();
+ ~safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR();
+ void initialize(const VkVideoEncodeSessionIntraRefreshCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeSessionIntraRefreshCreateInfoKHR* ptr() {
+ return reinterpret_cast<VkVideoEncodeSessionIntraRefreshCreateInfoKHR*>(this);
+ }
+ VkVideoEncodeSessionIntraRefreshCreateInfoKHR const* ptr() const {
+ return reinterpret_cast<VkVideoEncodeSessionIntraRefreshCreateInfoKHR const*>(this);
+ }
+};
+struct safe_VkVideoEncodeIntraRefreshInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ uint32_t intraRefreshCycleDuration;
+ uint32_t intraRefreshIndex;
+
+ safe_VkVideoEncodeIntraRefreshInfoKHR(const VkVideoEncodeIntraRefreshInfoKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkVideoEncodeIntraRefreshInfoKHR(const safe_VkVideoEncodeIntraRefreshInfoKHR& copy_src);
+ safe_VkVideoEncodeIntraRefreshInfoKHR& operator=(const safe_VkVideoEncodeIntraRefreshInfoKHR& copy_src);
+ safe_VkVideoEncodeIntraRefreshInfoKHR();
+ ~safe_VkVideoEncodeIntraRefreshInfoKHR();
+ void initialize(const VkVideoEncodeIntraRefreshInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeIntraRefreshInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeIntraRefreshInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeIntraRefreshInfoKHR*>(this); }
+ VkVideoEncodeIntraRefreshInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeIntraRefreshInfoKHR const*>(this); }
+};
+struct safe_VkVideoReferenceIntraRefreshInfoKHR {
+ VkStructureType sType;
+ const void* pNext{};
+ uint32_t dirtyIntraRefreshRegions;
+
+ safe_VkVideoReferenceIntraRefreshInfoKHR(const VkVideoReferenceIntraRefreshInfoKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkVideoReferenceIntraRefreshInfoKHR(const safe_VkVideoReferenceIntraRefreshInfoKHR& copy_src);
+ safe_VkVideoReferenceIntraRefreshInfoKHR& operator=(const safe_VkVideoReferenceIntraRefreshInfoKHR& copy_src);
+ safe_VkVideoReferenceIntraRefreshInfoKHR();
+ ~safe_VkVideoReferenceIntraRefreshInfoKHR();
+ void initialize(const VkVideoReferenceIntraRefreshInfoKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoReferenceIntraRefreshInfoKHR* copy_src, PNextCopyState* copy_state = {});
+ VkVideoReferenceIntraRefreshInfoKHR* ptr() { return reinterpret_cast<VkVideoReferenceIntraRefreshInfoKHR*>(this); }
+ VkVideoReferenceIntraRefreshInfoKHR const* ptr() const {
+ return reinterpret_cast<VkVideoReferenceIntraRefreshInfoKHR const*>(this);
+ }
+};
+struct safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkBool32 videoEncodeIntraRefresh;
+
+ safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(
+ const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& copy_src);
+ safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& operator=(
+ const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& copy_src);
+ safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR();
+ ~safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR();
+ void initialize(const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+ VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* ptr() {
+ return reinterpret_cast<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(this);
+ }
+ VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const* ptr() const {
+ return reinterpret_cast<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const*>(this);
+ }
+};
struct safe_VkVideoEncodeQuantizationMapCapabilitiesKHR {
VkStructureType sType;
void* pNext{};
@@ -10062,6 +10330,29 @@
return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesKHR const*>(this);
}
};
+struct safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
+ VkStructureType sType;
+ void* pNext{};
+ VkBool32 presentModeFifoLatestReady;
+
+ safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+ const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+ const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& copy_src);
+ safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& operator=(
+ const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& copy_src);
+ safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR();
+ ~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR();
+ void initialize(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+ VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* ptr() {
+ return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(this);
+ }
+ VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const* ptr() const {
+ return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const*>(this);
+ }
+};
struct safe_VkDebugReportCallbackCreateInfoEXT {
VkStructureType sType;
const void* pNext{};
@@ -13649,174 +13940,6 @@
return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const*>(this);
}
};
-struct safe_VkSurfacePresentModeEXT {
- VkStructureType sType;
- void* pNext{};
- VkPresentModeKHR presentMode;
-
- safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src);
- safe_VkSurfacePresentModeEXT& operator=(const safe_VkSurfacePresentModeEXT& copy_src);
- safe_VkSurfacePresentModeEXT();
- ~safe_VkSurfacePresentModeEXT();
- void initialize(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSurfacePresentModeEXT* copy_src, PNextCopyState* copy_state = {});
- VkSurfacePresentModeEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeEXT*>(this); }
- VkSurfacePresentModeEXT const* ptr() const { return reinterpret_cast<VkSurfacePresentModeEXT const*>(this); }
-};
-struct safe_VkSurfacePresentScalingCapabilitiesEXT {
- VkStructureType sType;
- void* pNext{};
- VkPresentScalingFlagsEXT supportedPresentScaling;
- VkPresentGravityFlagsEXT supportedPresentGravityX;
- VkPresentGravityFlagsEXT supportedPresentGravityY;
- VkExtent2D minScaledImageExtent;
- VkExtent2D maxScaledImageExtent;
-
- safe_VkSurfacePresentScalingCapabilitiesEXT(const VkSurfacePresentScalingCapabilitiesEXT* in_struct,
- PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkSurfacePresentScalingCapabilitiesEXT(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src);
- safe_VkSurfacePresentScalingCapabilitiesEXT& operator=(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src);
- safe_VkSurfacePresentScalingCapabilitiesEXT();
- ~safe_VkSurfacePresentScalingCapabilitiesEXT();
- void initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src, PNextCopyState* copy_state = {});
- VkSurfacePresentScalingCapabilitiesEXT* ptr() { return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(this); }
- VkSurfacePresentScalingCapabilitiesEXT const* ptr() const {
- return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT const*>(this);
- }
-};
-struct safe_VkSurfacePresentModeCompatibilityEXT {
- VkStructureType sType;
- void* pNext{};
- uint32_t presentModeCount;
- VkPresentModeKHR* pPresentModes{};
-
- safe_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* in_struct,
- PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkSurfacePresentModeCompatibilityEXT(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src);
- safe_VkSurfacePresentModeCompatibilityEXT& operator=(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src);
- safe_VkSurfacePresentModeCompatibilityEXT();
- ~safe_VkSurfacePresentModeCompatibilityEXT();
- void initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src, PNextCopyState* copy_state = {});
- VkSurfacePresentModeCompatibilityEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(this); }
- VkSurfacePresentModeCompatibilityEXT const* ptr() const {
- return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT const*>(this);
- }
-};
-struct safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT {
- VkStructureType sType;
- void* pNext{};
- VkBool32 swapchainMaintenance1;
-
- safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct,
- PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
- safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& operator=(
- const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
- safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT();
- ~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT();
- void initialize(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
- VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* ptr() {
- return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(this);
- }
- VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const* ptr() const {
- return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const*>(this);
- }
-};
-struct safe_VkSwapchainPresentFenceInfoEXT {
- VkStructureType sType;
- const void* pNext{};
- uint32_t swapchainCount;
- VkFence* pFences{};
-
- safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {},
- bool copy_pnext = true);
- safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src);
- safe_VkSwapchainPresentFenceInfoEXT& operator=(const safe_VkSwapchainPresentFenceInfoEXT& copy_src);
- safe_VkSwapchainPresentFenceInfoEXT();
- ~safe_VkSwapchainPresentFenceInfoEXT();
- void initialize(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src, PNextCopyState* copy_state = {});
- VkSwapchainPresentFenceInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(this); }
- VkSwapchainPresentFenceInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT const*>(this); }
-};
-struct safe_VkSwapchainPresentModesCreateInfoEXT {
- VkStructureType sType;
- const void* pNext{};
- uint32_t presentModeCount;
- const VkPresentModeKHR* pPresentModes{};
-
- safe_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* in_struct,
- PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkSwapchainPresentModesCreateInfoEXT(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src);
- safe_VkSwapchainPresentModesCreateInfoEXT& operator=(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src);
- safe_VkSwapchainPresentModesCreateInfoEXT();
- ~safe_VkSwapchainPresentModesCreateInfoEXT();
- void initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
- VkSwapchainPresentModesCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(this); }
- VkSwapchainPresentModesCreateInfoEXT const* ptr() const {
- return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT const*>(this);
- }
-};
-struct safe_VkSwapchainPresentModeInfoEXT {
- VkStructureType sType;
- const void* pNext{};
- uint32_t swapchainCount;
- const VkPresentModeKHR* pPresentModes{};
-
- safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {},
- bool copy_pnext = true);
- safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src);
- safe_VkSwapchainPresentModeInfoEXT& operator=(const safe_VkSwapchainPresentModeInfoEXT& copy_src);
- safe_VkSwapchainPresentModeInfoEXT();
- ~safe_VkSwapchainPresentModeInfoEXT();
- void initialize(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src, PNextCopyState* copy_state = {});
- VkSwapchainPresentModeInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(this); }
- VkSwapchainPresentModeInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentModeInfoEXT const*>(this); }
-};
-struct safe_VkSwapchainPresentScalingCreateInfoEXT {
- VkStructureType sType;
- const void* pNext{};
- VkPresentScalingFlagsEXT scalingBehavior;
- VkPresentGravityFlagsEXT presentGravityX;
- VkPresentGravityFlagsEXT presentGravityY;
-
- safe_VkSwapchainPresentScalingCreateInfoEXT(const VkSwapchainPresentScalingCreateInfoEXT* in_struct,
- PNextCopyState* copy_state = {}, bool copy_pnext = true);
- safe_VkSwapchainPresentScalingCreateInfoEXT(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src);
- safe_VkSwapchainPresentScalingCreateInfoEXT& operator=(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src);
- safe_VkSwapchainPresentScalingCreateInfoEXT();
- ~safe_VkSwapchainPresentScalingCreateInfoEXT();
- void initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
- VkSwapchainPresentScalingCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(this); }
- VkSwapchainPresentScalingCreateInfoEXT const* ptr() const {
- return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT const*>(this);
- }
-};
-struct safe_VkReleaseSwapchainImagesInfoEXT {
- VkStructureType sType;
- const void* pNext{};
- VkSwapchainKHR swapchain;
- uint32_t imageIndexCount;
- const uint32_t* pImageIndices{};
-
- safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {},
- bool copy_pnext = true);
- safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src);
- safe_VkReleaseSwapchainImagesInfoEXT& operator=(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src);
- safe_VkReleaseSwapchainImagesInfoEXT();
- ~safe_VkReleaseSwapchainImagesInfoEXT();
- void initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src, PNextCopyState* copy_state = {});
- VkReleaseSwapchainImagesInfoEXT* ptr() { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT*>(this); }
- VkReleaseSwapchainImagesInfoEXT const* ptr() const { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT const*>(this); }
-};
struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
VkStructureType sType;
void* pNext{};
@@ -14082,7 +14205,7 @@
};
struct safe_VkRenderPassTransformBeginInfoQCOM {
VkStructureType sType;
- void* pNext{};
+ const void* pNext{};
VkSurfaceTransformFlagBitsKHR transform;
safe_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {},
@@ -14100,7 +14223,7 @@
};
struct safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
VkStructureType sType;
- void* pNext{};
+ const void* pNext{};
VkSurfaceTransformFlagBitsKHR transform;
VkRect2D renderArea;
@@ -15900,29 +16023,6 @@
return reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const*>(this);
}
};
-struct safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT {
- VkStructureType sType;
- void* pNext{};
- VkBool32 presentModeFifoLatestReady;
-
- safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
- const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
- bool copy_pnext = true);
- safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
- const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src);
- safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& operator=(
- const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src);
- safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT();
- ~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT();
- void initialize(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
- void initialize(const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
- VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* ptr() {
- return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT*>(this);
- }
- VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT const* ptr() const {
- return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT const*>(this);
- }
-};
#ifdef VK_USE_PLATFORM_FUCHSIA
struct safe_VkImportMemoryZirconHandleInfoFUCHSIA {
VkStructureType sType;
@@ -21943,6 +22043,29 @@
return reinterpret_cast<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const*>(this);
}
};
+struct safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
+ VkStructureType sType;
+ void* pNext{};
+ VkBool32 pipelineCacheIncrementalMode;
+
+ safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(
+ const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(
+ const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& copy_src);
+ safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& operator=(
+ const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& copy_src);
+ safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC();
+ ~safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC();
+ void initialize(const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* copy_src, PNextCopyState* copy_state = {});
+ VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* ptr() {
+ return reinterpret_cast<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(this);
+ }
+ VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const* ptr() const {
+ return reinterpret_cast<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const*>(this);
+ }
+};
struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
VkStructureType sType;
const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 0c11e5c..6c3f2e9 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -468,6 +468,15 @@
template <> inline VkStructureType GetSType<VkReleaseCapturedPipelineDataInfoKHR>() { return VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryDataInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPipelineBinaryHandlesInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkSurfacePresentModeKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; }
+template <> inline VkStructureType GetSType<VkSurfacePresentScalingCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkSurfacePresentModeCompatibilityKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkSwapchainPresentFenceInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkSwapchainPresentModesCreateInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkSwapchainPresentModeInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkSwapchainPresentScalingCreateInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkReleaseSwapchainImagesInfoKHR>() { return VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR; }
template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
@@ -500,6 +509,11 @@
template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkVideoEncodeIntraRefreshCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeSessionIntraRefreshCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeIntraRefreshInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoReferenceIntraRefreshInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoFormatQuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; }
@@ -528,6 +542,7 @@
template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
@@ -723,15 +738,6 @@
template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; }
template <> inline VkStructureType GetSType<VkMemoryMapPlacedInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkSurfacePresentModeEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; }
-template <> inline VkStructureType GetSType<VkSurfacePresentScalingCapabilitiesEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; }
-template <> inline VkStructureType GetSType<VkSurfacePresentModeCompatibilityEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkSwapchainPresentFenceInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkSwapchainPresentModesCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkSwapchainPresentModeInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkSwapchainPresentScalingCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkReleaseSwapchainImagesInfoEXT>() { return VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkGraphicsShaderGroupCreateInfoNV>() { return VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; }
@@ -838,7 +844,6 @@
template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClipControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPipelineViewportDepthClipControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; }
#ifdef VK_USE_PLATFORM_FUCHSIA
template <> inline VkStructureType GetSType<VkImportMemoryZirconHandleInfoFUCHSIA>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; }
template <> inline VkStructureType GetSType<VkMemoryZirconHandlePropertiesFUCHSIA>() { return VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; }
@@ -1142,6 +1147,7 @@
#endif // VK_ENABLE_BETA_EXTENSIONS
template <> inline VkStructureType GetSType<VkRenderingEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index c4cad96..c38ce8b 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1306,24 +1306,6 @@
return "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
- return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
- return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
- return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
- return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
- return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
- return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
- return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
- return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT";
- case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT:
- return "VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
@@ -1560,8 +1542,6 @@
return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
- return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT";
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA";
case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
@@ -1902,6 +1882,24 @@
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC";
case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
return "VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
+ return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
+ return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
+ return "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
@@ -2114,6 +2112,16 @@
return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV";
case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR";
+ case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
@@ -2302,6 +2310,10 @@
return "VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
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_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC";
default:
return "Unhandled VkStructureType";
}
@@ -4086,8 +4098,8 @@
return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
- case VK_PRESENT_MODE_FIFO_LATEST_READY_EXT:
- return "VK_PRESENT_MODE_FIFO_LATEST_READY_EXT";
+ case VK_PRESENT_MODE_FIFO_LATEST_READY_KHR:
+ return "VK_PRESENT_MODE_FIFO_LATEST_READY_KHR";
default:
return "Unhandled VkPresentModeKHR";
}
@@ -8318,12 +8330,12 @@
return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR";
case VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR:
return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
- case VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT:
- return "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT";
case VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR:
return "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR";
case VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR:
return "VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR";
+ case VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR:
+ return "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR";
default:
return "Unhandled VkSwapchainCreateFlagBitsKHR";
}
@@ -8704,6 +8716,8 @@
return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR";
case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR:
return "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR";
+ case VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR:
+ return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR";
case VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR:
return "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR";
default:
@@ -8845,6 +8859,8 @@
return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR";
case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR:
return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR";
+ case VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR:
+ return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR";
case VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR:
return "VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR";
default:
@@ -9084,6 +9100,8 @@
#endif // __cplusplus
static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value) {
switch (input_value) {
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR";
case VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR:
return "VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR";
case VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR:
@@ -9264,6 +9282,64 @@
return ret;
}
#endif // __cplusplus
+static inline const char* string_VkPresentScalingFlagBitsKHR(VkPresentScalingFlagBitsKHR input_value) {
+ switch (input_value) {
+ case VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR:
+ return "VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR";
+ case VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR:
+ return "VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR";
+ case VK_PRESENT_SCALING_STRETCH_BIT_KHR:
+ return "VK_PRESENT_SCALING_STRETCH_BIT_KHR";
+ default:
+ return "Unhandled VkPresentScalingFlagBitsKHR";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkPresentScalingFlagsKHR(VkPresentScalingFlagsKHR input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkPresentScalingFlagBitsKHR(static_cast<VkPresentScalingFlagBitsKHR>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkPresentScalingFlagsKHR(0)");
+ return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkPresentGravityFlagBitsKHR(VkPresentGravityFlagBitsKHR input_value) {
+ switch (input_value) {
+ case VK_PRESENT_GRAVITY_MIN_BIT_KHR:
+ return "VK_PRESENT_GRAVITY_MIN_BIT_KHR";
+ case VK_PRESENT_GRAVITY_MAX_BIT_KHR:
+ return "VK_PRESENT_GRAVITY_MAX_BIT_KHR";
+ case VK_PRESENT_GRAVITY_CENTERED_BIT_KHR:
+ return "VK_PRESENT_GRAVITY_CENTERED_BIT_KHR";
+ default:
+ return "Unhandled VkPresentGravityFlagBitsKHR";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkPresentGravityFlagsKHR(VkPresentGravityFlagsKHR input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkPresentGravityFlagBitsKHR(static_cast<VkPresentGravityFlagBitsKHR>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkPresentGravityFlagsKHR(0)");
+ return ret;
+}
+#endif // __cplusplus
static inline const char* string_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEncodeAV1CapabilityFlagBitsKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR:
@@ -9276,6 +9352,8 @@
return "VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR";
+ case VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR:
+ return "VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR";
default:
return "Unhandled VkVideoEncodeAV1CapabilityFlagBitsKHR";
}
@@ -9386,6 +9464,39 @@
return ret;
}
#endif // __cplusplus
+static inline const char* string_VkVideoEncodeIntraRefreshModeFlagBitsKHR(VkVideoEncodeIntraRefreshModeFlagBitsKHR input_value) {
+ switch (input_value) {
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR";
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR";
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR";
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR";
+ case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR:
+ return "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR";
+ default:
+ return "Unhandled VkVideoEncodeIntraRefreshModeFlagBitsKHR";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeIntraRefreshModeFlagsKHR(VkVideoEncodeIntraRefreshModeFlagsKHR input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkVideoEncodeIntraRefreshModeFlagBitsKHR(static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkVideoEncodeIntraRefreshModeFlagsKHR(0)");
+ return ret;
+}
+#endif // __cplusplus
static inline const char* string_VkAccessFlagBits3KHR(uint64_t input_value) {
if (input_value == VK_ACCESS_3_NONE_KHR) return "VK_ACCESS_3_NONE_KHR";
return "Unhandled VkAccessFlagBits3KHR";
@@ -9721,64 +9832,6 @@
return ret;
}
#endif // __cplusplus
-static inline const char* string_VkPresentScalingFlagBitsEXT(VkPresentScalingFlagBitsEXT input_value) {
- switch (input_value) {
- case VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT:
- return "VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT";
- case VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT:
- return "VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT";
- case VK_PRESENT_SCALING_STRETCH_BIT_EXT:
- return "VK_PRESENT_SCALING_STRETCH_BIT_EXT";
- default:
- return "Unhandled VkPresentScalingFlagBitsEXT";
- }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkPresentScalingFlagsEXT(VkPresentScalingFlagsEXT input_value) {
- std::string ret;
- int index = 0;
- while(input_value) {
- if (input_value & 1) {
- if( !ret.empty()) ret.append("|");
- ret.append(string_VkPresentScalingFlagBitsEXT(static_cast<VkPresentScalingFlagBitsEXT>(1U << index)));
- }
- ++index;
- input_value >>= 1;
- }
- if (ret.empty()) ret.append("VkPresentScalingFlagsEXT(0)");
- return ret;
-}
-#endif // __cplusplus
-static inline const char* string_VkPresentGravityFlagBitsEXT(VkPresentGravityFlagBitsEXT input_value) {
- switch (input_value) {
- case VK_PRESENT_GRAVITY_MIN_BIT_EXT:
- return "VK_PRESENT_GRAVITY_MIN_BIT_EXT";
- case VK_PRESENT_GRAVITY_MAX_BIT_EXT:
- return "VK_PRESENT_GRAVITY_MAX_BIT_EXT";
- case VK_PRESENT_GRAVITY_CENTERED_BIT_EXT:
- return "VK_PRESENT_GRAVITY_CENTERED_BIT_EXT";
- default:
- return "Unhandled VkPresentGravityFlagBitsEXT";
- }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkPresentGravityFlagsEXT(VkPresentGravityFlagsEXT input_value) {
- std::string ret;
- int index = 0;
- while(input_value) {
- if (input_value & 1) {
- if( !ret.empty()) ret.append("|");
- ret.append(string_VkPresentGravityFlagBitsEXT(static_cast<VkPresentGravityFlagBitsEXT>(1U << index)));
- }
- ++index;
- input_value >>= 1;
- }
- if (ret.empty()) ret.append("VkPresentGravityFlagsEXT(0)");
- return ret;
-}
-#endif // __cplusplus
static inline const char* string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV input_value) {
switch (input_value) {
case VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV:
@@ -11622,6 +11675,24 @@
return "VkPipelineBinaryDataInfoKHR";
case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
return "VkPipelineBinaryHandlesInfoKHR";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
+ return "VkSurfacePresentModeKHR";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
+ return "VkSurfacePresentScalingCapabilitiesKHR";
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
+ return "VkSurfacePresentModeCompatibilityKHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+ return "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
+ return "VkSwapchainPresentFenceInfoKHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
+ return "VkSwapchainPresentModesCreateInfoKHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
+ return "VkSwapchainPresentModeInfoKHR";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
+ return "VkSwapchainPresentScalingCreateInfoKHR";
+ case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
+ return "VkReleaseSwapchainImagesInfoKHR";
case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
return "VkCooperativeMatrixPropertiesKHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
@@ -11686,6 +11757,16 @@
return "VkSetDescriptorBufferOffsetsInfoEXT";
case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
return "VkBindDescriptorBufferEmbeddedSamplersInfoEXT";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
+ return "VkVideoEncodeIntraRefreshCapabilitiesKHR";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
+ return "VkVideoEncodeSessionIntraRefreshCreateInfoKHR";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
+ return "VkVideoEncodeIntraRefreshInfoKHR";
+ case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
+ return "VkVideoReferenceIntraRefreshInfoKHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+ return "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VkVideoEncodeQuantizationMapCapabilitiesKHR";
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
@@ -11742,6 +11823,8 @@
return "VkPhysicalDeviceRobustness2FeaturesKHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
return "VkPhysicalDeviceRobustness2PropertiesKHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+ return "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR";
case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
return "VkDebugReportCallbackCreateInfoEXT";
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
@@ -12110,24 +12193,6 @@
return "VkMemoryMapPlacedInfoEXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
return "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
- return "VkSurfacePresentModeEXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
- return "VkSurfacePresentScalingCapabilitiesEXT";
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
- return "VkSurfacePresentModeCompatibilityEXT";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
- return "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
- return "VkSwapchainPresentFenceInfoEXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
- return "VkSwapchainPresentModesCreateInfoEXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
- return "VkSwapchainPresentModeInfoEXT";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
- return "VkSwapchainPresentScalingCreateInfoEXT";
- case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT:
- return "VkReleaseSwapchainImagesInfoEXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
return "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
@@ -12334,8 +12399,6 @@
return "VkPipelineViewportDepthClipControlCreateInfoEXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
return "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
- return "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT";
#ifdef VK_USE_PLATFORM_FUCHSIA
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
return "VkImportMemoryZirconHandleInfoFUCHSIA";
@@ -12926,6 +12989,8 @@
return "VkRenderingEndInfoEXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
return "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+ return "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC";
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
return "VkAccelerationStructureGeometryTrianglesDataKHR";
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 90959d1..ab02235 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.320"
+ "commit": "v1.4.321"
},
{
"name": "googletest",
@@ -46,4 +46,4 @@
"googletest": "GOOGLETEST_INSTALL_DIR",
"magic_enum": "MAGIC_ENUM_INSTALL_DIR"
}
-}
\ No newline at end of file
+}
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index e12aaba..0cf9f5d 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -5735,664 +5735,6 @@
pNext = SafePnextCopy(copy_src->pNext);
}
-safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType), presentMode(in_struct->presentMode) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
-}
-
-safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT()
- : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT), pNext(nullptr), presentMode() {}
-
-safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src) {
- sType = copy_src.sType;
- presentMode = copy_src.presentMode;
- pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSurfacePresentModeEXT& safe_VkSurfacePresentModeEXT::operator=(const safe_VkSurfacePresentModeEXT& copy_src) {
- if (©_src == this) return *this;
-
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- presentMode = copy_src.presentMode;
- pNext = SafePnextCopy(copy_src.pNext);
-
- return *this;
-}
-
-safe_VkSurfacePresentModeEXT::~safe_VkSurfacePresentModeEXT() { FreePnextChain(pNext); }
-
-void safe_VkSurfacePresentModeEXT::initialize(const VkSurfacePresentModeEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- FreePnextChain(pNext);
- sType = in_struct->sType;
- presentMode = in_struct->presentMode;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSurfacePresentModeEXT::initialize(const safe_VkSurfacePresentModeEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- presentMode = copy_src->presentMode;
- pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT(
- const VkSurfacePresentScalingCapabilitiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType),
- supportedPresentScaling(in_struct->supportedPresentScaling),
- supportedPresentGravityX(in_struct->supportedPresentGravityX),
- supportedPresentGravityY(in_struct->supportedPresentGravityY),
- minScaledImageExtent(in_struct->minScaledImageExtent),
- maxScaledImageExtent(in_struct->maxScaledImageExtent) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
-}
-
-safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT()
- : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT),
- pNext(nullptr),
- supportedPresentScaling(),
- supportedPresentGravityX(),
- supportedPresentGravityY(),
- minScaledImageExtent(),
- maxScaledImageExtent() {}
-
-safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT(
- const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) {
- sType = copy_src.sType;
- supportedPresentScaling = copy_src.supportedPresentScaling;
- supportedPresentGravityX = copy_src.supportedPresentGravityX;
- supportedPresentGravityY = copy_src.supportedPresentGravityY;
- minScaledImageExtent = copy_src.minScaledImageExtent;
- maxScaledImageExtent = copy_src.maxScaledImageExtent;
- pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSurfacePresentScalingCapabilitiesEXT& safe_VkSurfacePresentScalingCapabilitiesEXT::operator=(
- const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) {
- if (©_src == this) return *this;
-
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- supportedPresentScaling = copy_src.supportedPresentScaling;
- supportedPresentGravityX = copy_src.supportedPresentGravityX;
- supportedPresentGravityY = copy_src.supportedPresentGravityY;
- minScaledImageExtent = copy_src.minScaledImageExtent;
- maxScaledImageExtent = copy_src.maxScaledImageExtent;
- pNext = SafePnextCopy(copy_src.pNext);
-
- return *this;
-}
-
-safe_VkSurfacePresentScalingCapabilitiesEXT::~safe_VkSurfacePresentScalingCapabilitiesEXT() { FreePnextChain(pNext); }
-
-void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- FreePnextChain(pNext);
- sType = in_struct->sType;
- supportedPresentScaling = in_struct->supportedPresentScaling;
- supportedPresentGravityX = in_struct->supportedPresentGravityX;
- supportedPresentGravityY = in_struct->supportedPresentGravityY;
- minScaledImageExtent = in_struct->minScaledImageExtent;
- maxScaledImageExtent = in_struct->maxScaledImageExtent;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- supportedPresentScaling = copy_src->supportedPresentScaling;
- supportedPresentGravityX = copy_src->supportedPresentGravityX;
- supportedPresentGravityY = copy_src->supportedPresentGravityY;
- minScaledImageExtent = copy_src->minScaledImageExtent;
- maxScaledImageExtent = copy_src->maxScaledImageExtent;
- pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT(
- const VkSurfacePresentModeCompatibilityEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
- }
-}
-
-safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT()
- : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
-
-safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT(
- const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) {
- sType = copy_src.sType;
- presentModeCount = copy_src.presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
- }
-}
-
-safe_VkSurfacePresentModeCompatibilityEXT& safe_VkSurfacePresentModeCompatibilityEXT::operator=(
- const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) {
- if (©_src == this) return *this;
-
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- presentModeCount = copy_src.presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
- }
-
- return *this;
-}
-
-safe_VkSurfacePresentModeCompatibilityEXT::~safe_VkSurfacePresentModeCompatibilityEXT() {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-}
-
-void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
- sType = in_struct->sType;
- presentModeCount = in_struct->presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
- }
-}
-
-void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- presentModeCount = copy_src->presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src->pNext);
-
- if (copy_src->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
- }
-}
-
-safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
- const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType), swapchainMaintenance1(in_struct->swapchainMaintenance1) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
-}
-
-safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT()
- : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT), pNext(nullptr), swapchainMaintenance1() {}
-
-safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
- const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) {
- sType = copy_src.sType;
- swapchainMaintenance1 = copy_src.swapchainMaintenance1;
- pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::operator=(
- const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) {
- if (©_src == this) return *this;
-
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- swapchainMaintenance1 = copy_src.swapchainMaintenance1;
- pNext = SafePnextCopy(copy_src.pNext);
-
- return *this;
-}
-
-safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT() {
- FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize(
- const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
- FreePnextChain(pNext);
- sType = in_struct->sType;
- swapchainMaintenance1 = in_struct->swapchainMaintenance1;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize(
- const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- swapchainMaintenance1 = copy_src->swapchainMaintenance1;
- pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state,
- bool copy_pnext)
- : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pFences(nullptr) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
- if (swapchainCount && in_struct->pFences) {
- pFences = new VkFence[swapchainCount];
- for (uint32_t i = 0; i < swapchainCount; ++i) {
- pFences[i] = in_struct->pFences[i];
- }
- }
-}
-
-safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT()
- : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT), pNext(nullptr), swapchainCount(), pFences(nullptr) {}
-
-safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src) {
- sType = copy_src.sType;
- swapchainCount = copy_src.swapchainCount;
- pFences = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
- if (swapchainCount && copy_src.pFences) {
- pFences = new VkFence[swapchainCount];
- for (uint32_t i = 0; i < swapchainCount; ++i) {
- pFences[i] = copy_src.pFences[i];
- }
- }
-}
-
-safe_VkSwapchainPresentFenceInfoEXT& safe_VkSwapchainPresentFenceInfoEXT::operator=(
- const safe_VkSwapchainPresentFenceInfoEXT& copy_src) {
- if (©_src == this) return *this;
-
- if (pFences) delete[] pFences;
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- swapchainCount = copy_src.swapchainCount;
- pFences = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
- if (swapchainCount && copy_src.pFences) {
- pFences = new VkFence[swapchainCount];
- for (uint32_t i = 0; i < swapchainCount; ++i) {
- pFences[i] = copy_src.pFences[i];
- }
- }
-
- return *this;
-}
-
-safe_VkSwapchainPresentFenceInfoEXT::~safe_VkSwapchainPresentFenceInfoEXT() {
- if (pFences) delete[] pFences;
- FreePnextChain(pNext);
-}
-
-void safe_VkSwapchainPresentFenceInfoEXT::initialize(const VkSwapchainPresentFenceInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- if (pFences) delete[] pFences;
- FreePnextChain(pNext);
- sType = in_struct->sType;
- swapchainCount = in_struct->swapchainCount;
- pFences = nullptr;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- if (swapchainCount && in_struct->pFences) {
- pFences = new VkFence[swapchainCount];
- for (uint32_t i = 0; i < swapchainCount; ++i) {
- pFences[i] = in_struct->pFences[i];
- }
- }
-}
-
-void safe_VkSwapchainPresentFenceInfoEXT::initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- swapchainCount = copy_src->swapchainCount;
- pFences = nullptr;
- pNext = SafePnextCopy(copy_src->pNext);
- if (swapchainCount && copy_src->pFences) {
- pFences = new VkFence[swapchainCount];
- for (uint32_t i = 0; i < swapchainCount; ++i) {
- pFences[i] = copy_src->pFences[i];
- }
- }
-}
-
-safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT(
- const VkSwapchainPresentModesCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
- }
-}
-
-safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT()
- : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT),
- pNext(nullptr),
- presentModeCount(),
- pPresentModes(nullptr) {}
-
-safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT(
- const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) {
- sType = copy_src.sType;
- presentModeCount = copy_src.presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
- }
-}
-
-safe_VkSwapchainPresentModesCreateInfoEXT& safe_VkSwapchainPresentModesCreateInfoEXT::operator=(
- const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) {
- if (©_src == this) return *this;
-
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- presentModeCount = copy_src.presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
- }
-
- return *this;
-}
-
-safe_VkSwapchainPresentModesCreateInfoEXT::~safe_VkSwapchainPresentModesCreateInfoEXT() {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-}
-
-void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
- sType = in_struct->sType;
- presentModeCount = in_struct->presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
- }
-}
-
-void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- presentModeCount = copy_src->presentModeCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src->pNext);
-
- if (copy_src->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
- memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
- }
-}
-
-safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentModes(nullptr) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
- }
-}
-
-safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT()
- : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT), pNext(nullptr), swapchainCount(), pPresentModes(nullptr) {}
-
-safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src) {
- sType = copy_src.sType;
- swapchainCount = copy_src.swapchainCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
- }
-}
-
-safe_VkSwapchainPresentModeInfoEXT& safe_VkSwapchainPresentModeInfoEXT::operator=(
- const safe_VkSwapchainPresentModeInfoEXT& copy_src) {
- if (©_src == this) return *this;
-
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- swapchainCount = copy_src.swapchainCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
- memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
- }
-
- return *this;
-}
-
-safe_VkSwapchainPresentModeInfoEXT::~safe_VkSwapchainPresentModeInfoEXT() {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
-}
-
-void safe_VkSwapchainPresentModeInfoEXT::initialize(const VkSwapchainPresentModeInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- if (pPresentModes) delete[] pPresentModes;
- FreePnextChain(pNext);
- sType = in_struct->sType;
- swapchainCount = in_struct->swapchainCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
- if (in_struct->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
- memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
- }
-}
-
-void safe_VkSwapchainPresentModeInfoEXT::initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- swapchainCount = copy_src->swapchainCount;
- pPresentModes = nullptr;
- pNext = SafePnextCopy(copy_src->pNext);
-
- if (copy_src->pPresentModes) {
- pPresentModes = new VkPresentModeKHR[copy_src->swapchainCount];
- memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->swapchainCount);
- }
-}
-
-safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT(
- const VkSwapchainPresentScalingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
- : sType(in_struct->sType),
- scalingBehavior(in_struct->scalingBehavior),
- presentGravityX(in_struct->presentGravityX),
- presentGravityY(in_struct->presentGravityY) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
-}
-
-safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT()
- : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT),
- pNext(nullptr),
- scalingBehavior(),
- presentGravityX(),
- presentGravityY() {}
-
-safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT(
- const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) {
- sType = copy_src.sType;
- scalingBehavior = copy_src.scalingBehavior;
- presentGravityX = copy_src.presentGravityX;
- presentGravityY = copy_src.presentGravityY;
- pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSwapchainPresentScalingCreateInfoEXT& safe_VkSwapchainPresentScalingCreateInfoEXT::operator=(
- const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) {
- if (©_src == this) return *this;
-
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- scalingBehavior = copy_src.scalingBehavior;
- presentGravityX = copy_src.presentGravityX;
- presentGravityY = copy_src.presentGravityY;
- pNext = SafePnextCopy(copy_src.pNext);
-
- return *this;
-}
-
-safe_VkSwapchainPresentScalingCreateInfoEXT::~safe_VkSwapchainPresentScalingCreateInfoEXT() { FreePnextChain(pNext); }
-
-void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- FreePnextChain(pNext);
- sType = in_struct->sType;
- scalingBehavior = in_struct->scalingBehavior;
- presentGravityX = in_struct->presentGravityX;
- presentGravityY = in_struct->presentGravityY;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- scalingBehavior = copy_src->scalingBehavior;
- presentGravityX = copy_src->presentGravityX;
- presentGravityY = copy_src->presentGravityY;
- pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state,
- bool copy_pnext)
- : sType(in_struct->sType),
- swapchain(in_struct->swapchain),
- imageIndexCount(in_struct->imageIndexCount),
- pImageIndices(nullptr) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
- if (in_struct->pImageIndices) {
- pImageIndices = new uint32_t[in_struct->imageIndexCount];
- memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
- }
-}
-
-safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT()
- : sType(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT),
- pNext(nullptr),
- swapchain(),
- imageIndexCount(),
- pImageIndices(nullptr) {}
-
-safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) {
- sType = copy_src.sType;
- swapchain = copy_src.swapchain;
- imageIndexCount = copy_src.imageIndexCount;
- pImageIndices = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pImageIndices) {
- pImageIndices = new uint32_t[copy_src.imageIndexCount];
- memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
- }
-}
-
-safe_VkReleaseSwapchainImagesInfoEXT& safe_VkReleaseSwapchainImagesInfoEXT::operator=(
- const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) {
- if (©_src == this) return *this;
-
- if (pImageIndices) delete[] pImageIndices;
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- swapchain = copy_src.swapchain;
- imageIndexCount = copy_src.imageIndexCount;
- pImageIndices = nullptr;
- pNext = SafePnextCopy(copy_src.pNext);
-
- if (copy_src.pImageIndices) {
- pImageIndices = new uint32_t[copy_src.imageIndexCount];
- memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
- }
-
- return *this;
-}
-
-safe_VkReleaseSwapchainImagesInfoEXT::~safe_VkReleaseSwapchainImagesInfoEXT() {
- if (pImageIndices) delete[] pImageIndices;
- FreePnextChain(pNext);
-}
-
-void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct,
- [[maybe_unused]] PNextCopyState* copy_state) {
- if (pImageIndices) delete[] pImageIndices;
- FreePnextChain(pNext);
- sType = in_struct->sType;
- swapchain = in_struct->swapchain;
- imageIndexCount = in_struct->imageIndexCount;
- pImageIndices = nullptr;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
- if (in_struct->pImageIndices) {
- pImageIndices = new uint32_t[in_struct->imageIndexCount];
- memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
- }
-}
-
-void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src,
- [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- swapchain = copy_src->swapchain;
- imageIndexCount = copy_src->imageIndexCount;
- pImageIndices = nullptr;
- pNext = SafePnextCopy(copy_src->pNext);
-
- if (copy_src->pImageIndices) {
- pImageIndices = new uint32_t[copy_src->imageIndexCount];
- memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->imageIndexCount);
- }
-}
-
safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), texelBufferAlignment(in_struct->texelBufferAlignment) {
@@ -10329,59 +9671,6 @@
pNext = SafePnextCopy(copy_src->pNext);
}
-safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
- const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
- bool copy_pnext)
- : sType(in_struct->sType), presentModeFifoLatestReady(in_struct->presentModeFifoLatestReady) {
- if (copy_pnext) {
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
- }
-}
-
-safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT()
- : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT),
- pNext(nullptr),
- presentModeFifoLatestReady() {}
-
-safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
- const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src) {
- sType = copy_src.sType;
- presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
- pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::operator=(
- const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src) {
- if (©_src == this) return *this;
-
- FreePnextChain(pNext);
-
- sType = copy_src.sType;
- presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
- pNext = SafePnextCopy(copy_src.pNext);
-
- return *this;
-}
-
-safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT() {
- FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::initialize(
- const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
- FreePnextChain(pNext);
- sType = in_struct->sType;
- presentModeFifoLatestReady = in_struct->presentModeFifoLatestReady;
- pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::initialize(
- const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
- sType = copy_src->sType;
- presentModeFifoLatestReady = copy_src->presentModeFifoLatestReady;
- pNext = SafePnextCopy(copy_src->pNext);
-}
-
safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct,
[[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index b74d2ee..13a39e6 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -12186,6 +12186,664 @@
}
}
+safe_VkSurfacePresentModeKHR::safe_VkSurfacePresentModeKHR(const VkSurfacePresentModeKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), presentMode(in_struct->presentMode) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkSurfacePresentModeKHR::safe_VkSurfacePresentModeKHR()
+ : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR), pNext(nullptr), presentMode() {}
+
+safe_VkSurfacePresentModeKHR::safe_VkSurfacePresentModeKHR(const safe_VkSurfacePresentModeKHR& copy_src) {
+ sType = copy_src.sType;
+ presentMode = copy_src.presentMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfacePresentModeKHR& safe_VkSurfacePresentModeKHR::operator=(const safe_VkSurfacePresentModeKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ presentMode = copy_src.presentMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkSurfacePresentModeKHR::~safe_VkSurfacePresentModeKHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfacePresentModeKHR::initialize(const VkSurfacePresentModeKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ presentMode = in_struct->presentMode;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfacePresentModeKHR::initialize(const safe_VkSurfacePresentModeKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ presentMode = copy_src->presentMode;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfacePresentScalingCapabilitiesKHR::safe_VkSurfacePresentScalingCapabilitiesKHR(
+ const VkSurfacePresentScalingCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType),
+ supportedPresentScaling(in_struct->supportedPresentScaling),
+ supportedPresentGravityX(in_struct->supportedPresentGravityX),
+ supportedPresentGravityY(in_struct->supportedPresentGravityY),
+ minScaledImageExtent(in_struct->minScaledImageExtent),
+ maxScaledImageExtent(in_struct->maxScaledImageExtent) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkSurfacePresentScalingCapabilitiesKHR::safe_VkSurfacePresentScalingCapabilitiesKHR()
+ : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR),
+ pNext(nullptr),
+ supportedPresentScaling(),
+ supportedPresentGravityX(),
+ supportedPresentGravityY(),
+ minScaledImageExtent(),
+ maxScaledImageExtent() {}
+
+safe_VkSurfacePresentScalingCapabilitiesKHR::safe_VkSurfacePresentScalingCapabilitiesKHR(
+ const safe_VkSurfacePresentScalingCapabilitiesKHR& copy_src) {
+ sType = copy_src.sType;
+ supportedPresentScaling = copy_src.supportedPresentScaling;
+ supportedPresentGravityX = copy_src.supportedPresentGravityX;
+ supportedPresentGravityY = copy_src.supportedPresentGravityY;
+ minScaledImageExtent = copy_src.minScaledImageExtent;
+ maxScaledImageExtent = copy_src.maxScaledImageExtent;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfacePresentScalingCapabilitiesKHR& safe_VkSurfacePresentScalingCapabilitiesKHR::operator=(
+ const safe_VkSurfacePresentScalingCapabilitiesKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ supportedPresentScaling = copy_src.supportedPresentScaling;
+ supportedPresentGravityX = copy_src.supportedPresentGravityX;
+ supportedPresentGravityY = copy_src.supportedPresentGravityY;
+ minScaledImageExtent = copy_src.minScaledImageExtent;
+ maxScaledImageExtent = copy_src.maxScaledImageExtent;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkSurfacePresentScalingCapabilitiesKHR::~safe_VkSurfacePresentScalingCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfacePresentScalingCapabilitiesKHR::initialize(const VkSurfacePresentScalingCapabilitiesKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ supportedPresentScaling = in_struct->supportedPresentScaling;
+ supportedPresentGravityX = in_struct->supportedPresentGravityX;
+ supportedPresentGravityY = in_struct->supportedPresentGravityY;
+ minScaledImageExtent = in_struct->minScaledImageExtent;
+ maxScaledImageExtent = in_struct->maxScaledImageExtent;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfacePresentScalingCapabilitiesKHR::initialize(const safe_VkSurfacePresentScalingCapabilitiesKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ supportedPresentScaling = copy_src->supportedPresentScaling;
+ supportedPresentGravityX = copy_src->supportedPresentGravityX;
+ supportedPresentGravityY = copy_src->supportedPresentGravityY;
+ minScaledImageExtent = copy_src->minScaledImageExtent;
+ maxScaledImageExtent = copy_src->maxScaledImageExtent;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfacePresentModeCompatibilityKHR::safe_VkSurfacePresentModeCompatibilityKHR(
+ const VkSurfacePresentModeCompatibilityKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+ }
+}
+
+safe_VkSurfacePresentModeCompatibilityKHR::safe_VkSurfacePresentModeCompatibilityKHR()
+ : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
+
+safe_VkSurfacePresentModeCompatibilityKHR::safe_VkSurfacePresentModeCompatibilityKHR(
+ const safe_VkSurfacePresentModeCompatibilityKHR& copy_src) {
+ sType = copy_src.sType;
+ presentModeCount = copy_src.presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+ }
+}
+
+safe_VkSurfacePresentModeCompatibilityKHR& safe_VkSurfacePresentModeCompatibilityKHR::operator=(
+ const safe_VkSurfacePresentModeCompatibilityKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ presentModeCount = copy_src.presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+ }
+
+ return *this;
+}
+
+safe_VkSurfacePresentModeCompatibilityKHR::~safe_VkSurfacePresentModeCompatibilityKHR() {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+}
+
+void safe_VkSurfacePresentModeCompatibilityKHR::initialize(const VkSurfacePresentModeCompatibilityKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ presentModeCount = in_struct->presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+ }
+}
+
+void safe_VkSurfacePresentModeCompatibilityKHR::initialize(const safe_VkSurfacePresentModeCompatibilityKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ presentModeCount = copy_src->presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src->pNext);
+
+ if (copy_src->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
+ }
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(
+ const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), swapchainMaintenance1(in_struct->swapchainMaintenance1) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR()
+ : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), swapchainMaintenance1() {}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(
+ const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& copy_src) {
+ sType = copy_src.sType;
+ swapchainMaintenance1 = copy_src.swapchainMaintenance1;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::operator=(
+ const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ swapchainMaintenance1 = copy_src.swapchainMaintenance1;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::initialize(
+ const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ swapchainMaintenance1 = in_struct->swapchainMaintenance1;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::initialize(
+ const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ swapchainMaintenance1 = copy_src->swapchainMaintenance1;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainPresentFenceInfoKHR::safe_VkSwapchainPresentFenceInfoKHR(const VkSwapchainPresentFenceInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pFences(nullptr) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+ if (swapchainCount && in_struct->pFences) {
+ pFences = new VkFence[swapchainCount];
+ for (uint32_t i = 0; i < swapchainCount; ++i) {
+ pFences[i] = in_struct->pFences[i];
+ }
+ }
+}
+
+safe_VkSwapchainPresentFenceInfoKHR::safe_VkSwapchainPresentFenceInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR), pNext(nullptr), swapchainCount(), pFences(nullptr) {}
+
+safe_VkSwapchainPresentFenceInfoKHR::safe_VkSwapchainPresentFenceInfoKHR(const safe_VkSwapchainPresentFenceInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ swapchainCount = copy_src.swapchainCount;
+ pFences = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+ if (swapchainCount && copy_src.pFences) {
+ pFences = new VkFence[swapchainCount];
+ for (uint32_t i = 0; i < swapchainCount; ++i) {
+ pFences[i] = copy_src.pFences[i];
+ }
+ }
+}
+
+safe_VkSwapchainPresentFenceInfoKHR& safe_VkSwapchainPresentFenceInfoKHR::operator=(
+ const safe_VkSwapchainPresentFenceInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ if (pFences) delete[] pFences;
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ swapchainCount = copy_src.swapchainCount;
+ pFences = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+ if (swapchainCount && copy_src.pFences) {
+ pFences = new VkFence[swapchainCount];
+ for (uint32_t i = 0; i < swapchainCount; ++i) {
+ pFences[i] = copy_src.pFences[i];
+ }
+ }
+
+ return *this;
+}
+
+safe_VkSwapchainPresentFenceInfoKHR::~safe_VkSwapchainPresentFenceInfoKHR() {
+ if (pFences) delete[] pFences;
+ FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentFenceInfoKHR::initialize(const VkSwapchainPresentFenceInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ if (pFences) delete[] pFences;
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ swapchainCount = in_struct->swapchainCount;
+ pFences = nullptr;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ if (swapchainCount && in_struct->pFences) {
+ pFences = new VkFence[swapchainCount];
+ for (uint32_t i = 0; i < swapchainCount; ++i) {
+ pFences[i] = in_struct->pFences[i];
+ }
+ }
+}
+
+void safe_VkSwapchainPresentFenceInfoKHR::initialize(const safe_VkSwapchainPresentFenceInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ swapchainCount = copy_src->swapchainCount;
+ pFences = nullptr;
+ pNext = SafePnextCopy(copy_src->pNext);
+ if (swapchainCount && copy_src->pFences) {
+ pFences = new VkFence[swapchainCount];
+ for (uint32_t i = 0; i < swapchainCount; ++i) {
+ pFences[i] = copy_src->pFences[i];
+ }
+ }
+}
+
+safe_VkSwapchainPresentModesCreateInfoKHR::safe_VkSwapchainPresentModesCreateInfoKHR(
+ const VkSwapchainPresentModesCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+ }
+}
+
+safe_VkSwapchainPresentModesCreateInfoKHR::safe_VkSwapchainPresentModesCreateInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR),
+ pNext(nullptr),
+ presentModeCount(),
+ pPresentModes(nullptr) {}
+
+safe_VkSwapchainPresentModesCreateInfoKHR::safe_VkSwapchainPresentModesCreateInfoKHR(
+ const safe_VkSwapchainPresentModesCreateInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ presentModeCount = copy_src.presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+ }
+}
+
+safe_VkSwapchainPresentModesCreateInfoKHR& safe_VkSwapchainPresentModesCreateInfoKHR::operator=(
+ const safe_VkSwapchainPresentModesCreateInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ presentModeCount = copy_src.presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+ }
+
+ return *this;
+}
+
+safe_VkSwapchainPresentModesCreateInfoKHR::~safe_VkSwapchainPresentModesCreateInfoKHR() {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentModesCreateInfoKHR::initialize(const VkSwapchainPresentModesCreateInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ presentModeCount = in_struct->presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+ }
+}
+
+void safe_VkSwapchainPresentModesCreateInfoKHR::initialize(const safe_VkSwapchainPresentModesCreateInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ presentModeCount = copy_src->presentModeCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src->pNext);
+
+ if (copy_src->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
+ memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
+ }
+}
+
+safe_VkSwapchainPresentModeInfoKHR::safe_VkSwapchainPresentModeInfoKHR(const VkSwapchainPresentModeInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentModes(nullptr) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
+ }
+}
+
+safe_VkSwapchainPresentModeInfoKHR::safe_VkSwapchainPresentModeInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR), pNext(nullptr), swapchainCount(), pPresentModes(nullptr) {}
+
+safe_VkSwapchainPresentModeInfoKHR::safe_VkSwapchainPresentModeInfoKHR(const safe_VkSwapchainPresentModeInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ swapchainCount = copy_src.swapchainCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
+ }
+}
+
+safe_VkSwapchainPresentModeInfoKHR& safe_VkSwapchainPresentModeInfoKHR::operator=(
+ const safe_VkSwapchainPresentModeInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ swapchainCount = copy_src.swapchainCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
+ memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
+ }
+
+ return *this;
+}
+
+safe_VkSwapchainPresentModeInfoKHR::~safe_VkSwapchainPresentModeInfoKHR() {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentModeInfoKHR::initialize(const VkSwapchainPresentModeInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ if (pPresentModes) delete[] pPresentModes;
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ swapchainCount = in_struct->swapchainCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+ if (in_struct->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
+ memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
+ }
+}
+
+void safe_VkSwapchainPresentModeInfoKHR::initialize(const safe_VkSwapchainPresentModeInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ swapchainCount = copy_src->swapchainCount;
+ pPresentModes = nullptr;
+ pNext = SafePnextCopy(copy_src->pNext);
+
+ if (copy_src->pPresentModes) {
+ pPresentModes = new VkPresentModeKHR[copy_src->swapchainCount];
+ memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->swapchainCount);
+ }
+}
+
+safe_VkSwapchainPresentScalingCreateInfoKHR::safe_VkSwapchainPresentScalingCreateInfoKHR(
+ const VkSwapchainPresentScalingCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType),
+ scalingBehavior(in_struct->scalingBehavior),
+ presentGravityX(in_struct->presentGravityX),
+ presentGravityY(in_struct->presentGravityY) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkSwapchainPresentScalingCreateInfoKHR::safe_VkSwapchainPresentScalingCreateInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR),
+ pNext(nullptr),
+ scalingBehavior(),
+ presentGravityX(),
+ presentGravityY() {}
+
+safe_VkSwapchainPresentScalingCreateInfoKHR::safe_VkSwapchainPresentScalingCreateInfoKHR(
+ const safe_VkSwapchainPresentScalingCreateInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ scalingBehavior = copy_src.scalingBehavior;
+ presentGravityX = copy_src.presentGravityX;
+ presentGravityY = copy_src.presentGravityY;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainPresentScalingCreateInfoKHR& safe_VkSwapchainPresentScalingCreateInfoKHR::operator=(
+ const safe_VkSwapchainPresentScalingCreateInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ scalingBehavior = copy_src.scalingBehavior;
+ presentGravityX = copy_src.presentGravityX;
+ presentGravityY = copy_src.presentGravityY;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkSwapchainPresentScalingCreateInfoKHR::~safe_VkSwapchainPresentScalingCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainPresentScalingCreateInfoKHR::initialize(const VkSwapchainPresentScalingCreateInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ scalingBehavior = in_struct->scalingBehavior;
+ presentGravityX = in_struct->presentGravityX;
+ presentGravityY = in_struct->presentGravityY;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainPresentScalingCreateInfoKHR::initialize(const safe_VkSwapchainPresentScalingCreateInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ scalingBehavior = copy_src->scalingBehavior;
+ presentGravityX = copy_src->presentGravityX;
+ presentGravityY = copy_src->presentGravityY;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkReleaseSwapchainImagesInfoKHR::safe_VkReleaseSwapchainImagesInfoKHR(const VkReleaseSwapchainImagesInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType),
+ swapchain(in_struct->swapchain),
+ imageIndexCount(in_struct->imageIndexCount),
+ pImageIndices(nullptr) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+ if (in_struct->pImageIndices) {
+ pImageIndices = new uint32_t[in_struct->imageIndexCount];
+ memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
+ }
+}
+
+safe_VkReleaseSwapchainImagesInfoKHR::safe_VkReleaseSwapchainImagesInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR),
+ pNext(nullptr),
+ swapchain(),
+ imageIndexCount(),
+ pImageIndices(nullptr) {}
+
+safe_VkReleaseSwapchainImagesInfoKHR::safe_VkReleaseSwapchainImagesInfoKHR(const safe_VkReleaseSwapchainImagesInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ swapchain = copy_src.swapchain;
+ imageIndexCount = copy_src.imageIndexCount;
+ pImageIndices = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pImageIndices) {
+ pImageIndices = new uint32_t[copy_src.imageIndexCount];
+ memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
+ }
+}
+
+safe_VkReleaseSwapchainImagesInfoKHR& safe_VkReleaseSwapchainImagesInfoKHR::operator=(
+ const safe_VkReleaseSwapchainImagesInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ if (pImageIndices) delete[] pImageIndices;
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ swapchain = copy_src.swapchain;
+ imageIndexCount = copy_src.imageIndexCount;
+ pImageIndices = nullptr;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ if (copy_src.pImageIndices) {
+ pImageIndices = new uint32_t[copy_src.imageIndexCount];
+ memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
+ }
+
+ return *this;
+}
+
+safe_VkReleaseSwapchainImagesInfoKHR::~safe_VkReleaseSwapchainImagesInfoKHR() {
+ if (pImageIndices) delete[] pImageIndices;
+ FreePnextChain(pNext);
+}
+
+void safe_VkReleaseSwapchainImagesInfoKHR::initialize(const VkReleaseSwapchainImagesInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ if (pImageIndices) delete[] pImageIndices;
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ swapchain = in_struct->swapchain;
+ imageIndexCount = in_struct->imageIndexCount;
+ pImageIndices = nullptr;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+ if (in_struct->pImageIndices) {
+ pImageIndices = new uint32_t[in_struct->imageIndexCount];
+ memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
+ }
+}
+
+void safe_VkReleaseSwapchainImagesInfoKHR::initialize(const safe_VkReleaseSwapchainImagesInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ swapchain = copy_src->swapchain;
+ imageIndexCount = copy_src->imageIndexCount;
+ pImageIndices = nullptr;
+ pNext = SafePnextCopy(copy_src->pNext);
+
+ if (copy_src->pImageIndices) {
+ pImageIndices = new uint32_t[copy_src->imageIndexCount];
+ memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->imageIndexCount);
+ }
+}
+
safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct,
[[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
@@ -14437,6 +15095,286 @@
pNext = SafePnextCopy(copy_src->pNext);
}
+safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(
+ const VkVideoEncodeIntraRefreshCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType),
+ intraRefreshModes(in_struct->intraRefreshModes),
+ maxIntraRefreshCycleDuration(in_struct->maxIntraRefreshCycleDuration),
+ maxIntraRefreshActiveReferencePictures(in_struct->maxIntraRefreshActiveReferencePictures),
+ partitionIndependentIntraRefreshRegions(in_struct->partitionIndependentIntraRefreshRegions),
+ nonRectangularIntraRefreshRegions(in_struct->nonRectangularIntraRefreshRegions) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::safe_VkVideoEncodeIntraRefreshCapabilitiesKHR()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR),
+ pNext(nullptr),
+ intraRefreshModes(),
+ maxIntraRefreshCycleDuration(),
+ maxIntraRefreshActiveReferencePictures(),
+ partitionIndependentIntraRefreshRegions(),
+ nonRectangularIntraRefreshRegions() {}
+
+safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(
+ const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& copy_src) {
+ sType = copy_src.sType;
+ intraRefreshModes = copy_src.intraRefreshModes;
+ maxIntraRefreshCycleDuration = copy_src.maxIntraRefreshCycleDuration;
+ maxIntraRefreshActiveReferencePictures = copy_src.maxIntraRefreshActiveReferencePictures;
+ partitionIndependentIntraRefreshRegions = copy_src.partitionIndependentIntraRefreshRegions;
+ nonRectangularIntraRefreshRegions = copy_src.nonRectangularIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::operator=(
+ const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ intraRefreshModes = copy_src.intraRefreshModes;
+ maxIntraRefreshCycleDuration = copy_src.maxIntraRefreshCycleDuration;
+ maxIntraRefreshActiveReferencePictures = copy_src.maxIntraRefreshActiveReferencePictures;
+ partitionIndependentIntraRefreshRegions = copy_src.partitionIndependentIntraRefreshRegions;
+ nonRectangularIntraRefreshRegions = copy_src.nonRectangularIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::~safe_VkVideoEncodeIntraRefreshCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::initialize(const VkVideoEncodeIntraRefreshCapabilitiesKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ intraRefreshModes = in_struct->intraRefreshModes;
+ maxIntraRefreshCycleDuration = in_struct->maxIntraRefreshCycleDuration;
+ maxIntraRefreshActiveReferencePictures = in_struct->maxIntraRefreshActiveReferencePictures;
+ partitionIndependentIntraRefreshRegions = in_struct->partitionIndependentIntraRefreshRegions;
+ nonRectangularIntraRefreshRegions = in_struct->nonRectangularIntraRefreshRegions;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::initialize(const safe_VkVideoEncodeIntraRefreshCapabilitiesKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ intraRefreshModes = copy_src->intraRefreshModes;
+ maxIntraRefreshCycleDuration = copy_src->maxIntraRefreshCycleDuration;
+ maxIntraRefreshActiveReferencePictures = copy_src->maxIntraRefreshActiveReferencePictures;
+ partitionIndependentIntraRefreshRegions = copy_src->partitionIndependentIntraRefreshRegions;
+ nonRectangularIntraRefreshRegions = copy_src->nonRectangularIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(
+ const VkVideoEncodeSessionIntraRefreshCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), intraRefreshMode(in_struct->intraRefreshMode) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR), pNext(nullptr), intraRefreshMode() {}
+
+safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(
+ const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ intraRefreshMode = copy_src.intraRefreshMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::operator=(
+ const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ intraRefreshMode = copy_src.intraRefreshMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::~safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::initialize(const VkVideoEncodeSessionIntraRefreshCreateInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ intraRefreshMode = in_struct->intraRefreshMode;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR::initialize(
+ const safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ intraRefreshMode = copy_src->intraRefreshMode;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeIntraRefreshInfoKHR::safe_VkVideoEncodeIntraRefreshInfoKHR(const VkVideoEncodeIntraRefreshInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType),
+ intraRefreshCycleDuration(in_struct->intraRefreshCycleDuration),
+ intraRefreshIndex(in_struct->intraRefreshIndex) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeIntraRefreshInfoKHR::safe_VkVideoEncodeIntraRefreshInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR),
+ pNext(nullptr),
+ intraRefreshCycleDuration(),
+ intraRefreshIndex() {}
+
+safe_VkVideoEncodeIntraRefreshInfoKHR::safe_VkVideoEncodeIntraRefreshInfoKHR(
+ const safe_VkVideoEncodeIntraRefreshInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ intraRefreshCycleDuration = copy_src.intraRefreshCycleDuration;
+ intraRefreshIndex = copy_src.intraRefreshIndex;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeIntraRefreshInfoKHR& safe_VkVideoEncodeIntraRefreshInfoKHR::operator=(
+ const safe_VkVideoEncodeIntraRefreshInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ intraRefreshCycleDuration = copy_src.intraRefreshCycleDuration;
+ intraRefreshIndex = copy_src.intraRefreshIndex;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeIntraRefreshInfoKHR::~safe_VkVideoEncodeIntraRefreshInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeIntraRefreshInfoKHR::initialize(const VkVideoEncodeIntraRefreshInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ intraRefreshCycleDuration = in_struct->intraRefreshCycleDuration;
+ intraRefreshIndex = in_struct->intraRefreshIndex;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeIntraRefreshInfoKHR::initialize(const safe_VkVideoEncodeIntraRefreshInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ intraRefreshCycleDuration = copy_src->intraRefreshCycleDuration;
+ intraRefreshIndex = copy_src->intraRefreshIndex;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoReferenceIntraRefreshInfoKHR::safe_VkVideoReferenceIntraRefreshInfoKHR(
+ const VkVideoReferenceIntraRefreshInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), dirtyIntraRefreshRegions(in_struct->dirtyIntraRefreshRegions) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoReferenceIntraRefreshInfoKHR::safe_VkVideoReferenceIntraRefreshInfoKHR()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR), pNext(nullptr), dirtyIntraRefreshRegions() {}
+
+safe_VkVideoReferenceIntraRefreshInfoKHR::safe_VkVideoReferenceIntraRefreshInfoKHR(
+ const safe_VkVideoReferenceIntraRefreshInfoKHR& copy_src) {
+ sType = copy_src.sType;
+ dirtyIntraRefreshRegions = copy_src.dirtyIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoReferenceIntraRefreshInfoKHR& safe_VkVideoReferenceIntraRefreshInfoKHR::operator=(
+ const safe_VkVideoReferenceIntraRefreshInfoKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ dirtyIntraRefreshRegions = copy_src.dirtyIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoReferenceIntraRefreshInfoKHR::~safe_VkVideoReferenceIntraRefreshInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoReferenceIntraRefreshInfoKHR::initialize(const VkVideoReferenceIntraRefreshInfoKHR* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ dirtyIntraRefreshRegions = in_struct->dirtyIntraRefreshRegions;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoReferenceIntraRefreshInfoKHR::initialize(const safe_VkVideoReferenceIntraRefreshInfoKHR* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ dirtyIntraRefreshRegions = copy_src->dirtyIntraRefreshRegions;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(
+ const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType), videoEncodeIntraRefresh(in_struct->videoEncodeIntraRefresh) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR()
+ : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR), pNext(nullptr), videoEncodeIntraRefresh() {}
+
+safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(
+ const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& copy_src) {
+ sType = copy_src.sType;
+ videoEncodeIntraRefresh = copy_src.videoEncodeIntraRefresh;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::operator=(
+ const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ videoEncodeIntraRefresh = copy_src.videoEncodeIntraRefresh;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::~safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::initialize(
+ const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ videoEncodeIntraRefresh = in_struct->videoEncodeIntraRefresh;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::initialize(
+ const safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ videoEncodeIntraRefresh = copy_src->videoEncodeIntraRefresh;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(
const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), maxQuantizationMapExtent(in_struct->maxQuantizationMapExtent) {
@@ -16144,6 +17082,59 @@
pNext = SafePnextCopy(copy_src->pNext);
}
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+ const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType), presentModeFifoLatestReady(in_struct->presentModeFifoLatestReady) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR()
+ : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR),
+ pNext(nullptr),
+ presentModeFifoLatestReady() {}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+ const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& copy_src) {
+ sType = copy_src.sType;
+ presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::operator=(
+ const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::initialize(
+ const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ presentModeFifoLatestReady = in_struct->presentModeFifoLatestReady;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::initialize(
+ const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ presentModeFifoLatestReady = copy_src->presentModeFifoLatestReady;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
PNextCopyState*) {
initialize(in_struct);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 09185e8..f71d411 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -794,6 +794,30 @@
case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
safe_pNext = new safe_VkPipelineBinaryInfoKHR(reinterpret_cast<const VkPipelineBinaryInfoKHR *>(pNext), copy_state, false);
break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
+ safe_pNext = new safe_VkSurfacePresentModeKHR(reinterpret_cast<const VkSurfacePresentModeKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
+ safe_pNext = new safe_VkSurfacePresentScalingCapabilitiesKHR(reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
+ safe_pNext = new safe_VkSurfacePresentModeCompatibilityKHR(reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+ safe_pNext = new safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
+ safe_pNext = new safe_VkSwapchainPresentFenceInfoKHR(reinterpret_cast<const VkSwapchainPresentFenceInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
+ safe_pNext = new safe_VkSwapchainPresentModesCreateInfoKHR(reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
+ safe_pNext = new safe_VkSwapchainPresentModeInfoKHR(reinterpret_cast<const VkSwapchainPresentModeInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
+ safe_pNext = new safe_VkSwapchainPresentScalingCreateInfoKHR(reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR *>(pNext), copy_state, false);
+ break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false);
break;
@@ -878,6 +902,21 @@
case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
safe_pNext = new safe_VkAttachmentFeedbackLoopInfoEXT(reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT *>(pNext), copy_state, false);
break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
+ safe_pNext = new safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
+ safe_pNext = new safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
+ safe_pNext = new safe_VkVideoEncodeIntraRefreshInfoKHR(reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
+ safe_pNext = new safe_VkVideoReferenceIntraRefreshInfoKHR(reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+ safe_pNext = new safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(pNext), copy_state, false);
+ break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
break;
@@ -959,6 +998,9 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR *>(pNext), copy_state, false);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+ safe_pNext = new safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(pNext), copy_state, false);
+ break;
case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
break;
@@ -1341,30 +1383,6 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(pNext), copy_state, false);
break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
- safe_pNext = new safe_VkSurfacePresentModeEXT(reinterpret_cast<const VkSurfacePresentModeEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
- safe_pNext = new safe_VkSurfacePresentScalingCapabilitiesEXT(reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
- safe_pNext = new safe_VkSurfacePresentModeCompatibilityEXT(reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
- safe_pNext = new safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
- safe_pNext = new safe_VkSwapchainPresentFenceInfoEXT(reinterpret_cast<const VkSwapchainPresentFenceInfoEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
- safe_pNext = new safe_VkSwapchainPresentModesCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
- safe_pNext = new safe_VkSwapchainPresentModeInfoEXT(reinterpret_cast<const VkSwapchainPresentModeInfoEXT *>(pNext), copy_state, false);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
- safe_pNext = new safe_VkSwapchainPresentScalingCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT *>(pNext), copy_state, false);
- break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(pNext), copy_state, false);
break;
@@ -1588,9 +1606,6 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(pNext), copy_state, false);
break;
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
- safe_pNext = new safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *>(pNext), copy_state, false);
- break;
#ifdef VK_USE_PLATFORM_FUCHSIA
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext), copy_state, false);
@@ -2185,6 +2200,9 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(pNext), copy_state, false);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+ safe_pNext = new safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(pNext), copy_state, false);
+ break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
break;
@@ -2995,6 +3013,30 @@
case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
delete reinterpret_cast<safe_VkPipelineBinaryInfoKHR *>(header);
break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
+ delete reinterpret_cast<safe_VkSurfacePresentModeKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
+ delete reinterpret_cast<safe_VkSurfacePresentScalingCapabilitiesKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
+ delete reinterpret_cast<safe_VkSurfacePresentModeCompatibilityKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+ delete reinterpret_cast<safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
+ delete reinterpret_cast<safe_VkSwapchainPresentFenceInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
+ delete reinterpret_cast<safe_VkSwapchainPresentModesCreateInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
+ delete reinterpret_cast<safe_VkSwapchainPresentModeInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
+ delete reinterpret_cast<safe_VkSwapchainPresentScalingCreateInfoKHR *>(header);
+ break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
break;
@@ -3079,6 +3121,21 @@
case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
delete reinterpret_cast<safe_VkAttachmentFeedbackLoopInfoEXT *>(header);
break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
+ delete reinterpret_cast<safe_VkVideoEncodeIntraRefreshCapabilitiesKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
+ delete reinterpret_cast<safe_VkVideoEncodeSessionIntraRefreshCreateInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
+ delete reinterpret_cast<safe_VkVideoEncodeIntraRefreshInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
+ delete reinterpret_cast<safe_VkVideoReferenceIntraRefreshInfoKHR *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+ delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(header);
+ break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
break;
@@ -3160,6 +3217,9 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2PropertiesKHR *>(header);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+ delete reinterpret_cast<safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(header);
+ break;
case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
break;
@@ -3542,30 +3602,6 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
- delete reinterpret_cast<safe_VkSurfacePresentModeEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
- delete reinterpret_cast<safe_VkSurfacePresentScalingCapabilitiesEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
- delete reinterpret_cast<safe_VkSurfacePresentModeCompatibilityEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
- delete reinterpret_cast<safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
- delete reinterpret_cast<safe_VkSwapchainPresentFenceInfoEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
- delete reinterpret_cast<safe_VkSwapchainPresentModesCreateInfoEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
- delete reinterpret_cast<safe_VkSwapchainPresentModeInfoEXT *>(header);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
- delete reinterpret_cast<safe_VkSwapchainPresentScalingCreateInfoEXT *>(header);
- break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
break;
@@ -3789,9 +3825,6 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
break;
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
- delete reinterpret_cast<safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *>(header);
- break;
#ifdef VK_USE_PLATFORM_FUCHSIA
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
delete reinterpret_cast<safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
@@ -4386,6 +4419,9 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(header);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+ delete reinterpret_cast<safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(header);
+ break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 8d1d249..6c89838 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -21887,6 +21887,60 @@
}
#endif // VK_ENABLE_BETA_EXTENSIONS
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(
+ const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType), pipelineCacheIncrementalMode(in_struct->pipelineCacheIncrementalMode) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC()
+ : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC),
+ pNext(nullptr),
+ pipelineCacheIncrementalMode() {}
+
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(
+ const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& copy_src) {
+ sType = copy_src.sType;
+ pipelineCacheIncrementalMode = copy_src.pipelineCacheIncrementalMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC&
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::operator=(
+ const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ pipelineCacheIncrementalMode = copy_src.pipelineCacheIncrementalMode;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::~safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::initialize(
+ const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ pipelineCacheIncrementalMode = in_struct->pipelineCacheIncrementalMode;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::initialize(
+ const safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ pipelineCacheIncrementalMode = copy_src->pipelineCacheIncrementalMode;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
} // namespace vku
// NOLINTEND
