eden-emu/Vulkan-Utility-Libraries
15
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git synced 2025-05-22 04:38:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

build: Update to header 1.3.302

Browse source
This commit is contained in:
Mike Schuchardt 2024-11-21 06:56:02 -08:00
parent c31e717dcd
commit b538fb5b08
9 changed files with 2760 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/vulkan/utility/vk_dispatch_table.h
View file

@ -490,6 +490,7 @@ typedef struct VkuDeviceDispatchTable_ {
PFN_vkDestroyCuFunctionNVX DestroyCuFunctionNVX; PFN_vkDestroyCuFunctionNVX DestroyCuFunctionNVX;
PFN_vkCmdCuLaunchKernelNVX CmdCuLaunchKernelNVX; PFN_vkCmdCuLaunchKernelNVX CmdCuLaunchKernelNVX;
PFN_vkGetImageViewHandleNVX GetImageViewHandleNVX; PFN_vkGetImageViewHandleNVX GetImageViewHandleNVX;
PFN_vkGetImageViewHandle64NVX GetImageViewHandle64NVX;
PFN_vkGetImageViewAddressNVX GetImageViewAddressNVX; PFN_vkGetImageViewAddressNVX GetImageViewAddressNVX;
PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD; PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD; PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
@ -1102,6 +1103,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
table->DestroyCuFunctionNVX = (PFN_vkDestroyCuFunctionNVX)gdpa(device, "vkDestroyCuFunctionNVX"); table->DestroyCuFunctionNVX = (PFN_vkDestroyCuFunctionNVX)gdpa(device, "vkDestroyCuFunctionNVX");
table->CmdCuLaunchKernelNVX = (PFN_vkCmdCuLaunchKernelNVX)gdpa(device, "vkCmdCuLaunchKernelNVX"); table->CmdCuLaunchKernelNVX = (PFN_vkCmdCuLaunchKernelNVX)gdpa(device, "vkCmdCuLaunchKernelNVX");
table->GetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)gdpa(device, "vkGetImageViewHandleNVX"); table->GetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)gdpa(device, "vkGetImageViewHandleNVX");
table->GetImageViewHandle64NVX = (PFN_vkGetImageViewHandle64NVX)gdpa(device, "vkGetImageViewHandle64NVX");
table->GetImageViewAddressNVX = (PFN_vkGetImageViewAddressNVX)gdpa(device, "vkGetImageViewAddressNVX"); table->GetImageViewAddressNVX = (PFN_vkGetImageViewAddressNVX)gdpa(device, "vkGetImageViewAddressNVX");
table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gdpa(device, "vkCmdDrawIndirectCountAMD"); table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gdpa(device, "vkCmdDrawIndirectCountAMD");
table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD"); table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD");

537
include/vulkan/utility/vk_safe_struct.hpp
View file

@ -8229,6 +8229,258 @@ struct safe_VkVideoDecodeAV1DpbSlotInfoKHR {
VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR*>(this); } VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR*>(this); }
VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR const*>(this); } VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR const*>(this); }
}; };
struct safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
VkStructureType sType;
void* pNext{};
VkBool32 videoEncodeAV1;
safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src);
safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src);
safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR();
~safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR();
void initialize(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(this); }
VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1CapabilitiesKHR {
VkStructureType sType;
void* pNext{};
VkVideoEncodeAV1CapabilityFlagsKHR flags;
StdVideoAV1Level maxLevel;
VkExtent2D codedPictureAlignment;
VkExtent2D maxTiles;
VkExtent2D minTileSize;
VkExtent2D maxTileSize;
VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes;
uint32_t maxSingleReferenceCount;
uint32_t singleReferenceNameMask;
uint32_t maxUnidirectionalCompoundReferenceCount;
uint32_t maxUnidirectionalCompoundGroup1ReferenceCount;
uint32_t unidirectionalCompoundReferenceNameMask;
uint32_t maxBidirectionalCompoundReferenceCount;
uint32_t maxBidirectionalCompoundGroup1ReferenceCount;
uint32_t maxBidirectionalCompoundGroup2ReferenceCount;
uint32_t bidirectionalCompoundReferenceNameMask;
uint32_t maxTemporalLayerCount;
uint32_t maxSpatialLayerCount;
uint32_t maxOperatingPoints;
uint32_t minQIndex;
uint32_t maxQIndex;
VkBool32 prefersGopRemainingFrames;
VkBool32 requiresGopRemainingFrames;
VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags;
safe_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeAV1CapabilitiesKHR(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src);
safe_VkVideoEncodeAV1CapabilitiesKHR& operator=(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src);
safe_VkVideoEncodeAV1CapabilitiesKHR();
~safe_VkVideoEncodeAV1CapabilitiesKHR();
void initialize(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1CapabilitiesKHR*>(this); }
VkVideoEncodeAV1CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1CapabilitiesKHR const*>(this); }
};
struct safe_VkVideoEncodeAV1QualityLevelPropertiesKHR {
VkStructureType sType;
void* pNext{};
VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags;
uint32_t preferredGopFrameCount;
uint32_t preferredKeyFramePeriod;
uint32_t preferredConsecutiveBipredictiveFrameCount;
uint32_t preferredTemporalLayerCount;
VkVideoEncodeAV1QIndexKHR preferredConstantQIndex;
uint32_t preferredMaxSingleReferenceCount;
uint32_t preferredSingleReferenceNameMask;
uint32_t preferredMaxUnidirectionalCompoundReferenceCount;
uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
uint32_t preferredUnidirectionalCompoundReferenceNameMask;
uint32_t preferredMaxBidirectionalCompoundReferenceCount;
uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount;
uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount;
uint32_t preferredBidirectionalCompoundReferenceNameMask;
safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src);
safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src);
safe_VkVideoEncodeAV1QualityLevelPropertiesKHR();
~safe_VkVideoEncodeAV1QualityLevelPropertiesKHR();
void initialize(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1QualityLevelPropertiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1QualityLevelPropertiesKHR*>(this); }
VkVideoEncodeAV1QualityLevelPropertiesKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1QualityLevelPropertiesKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1SessionCreateInfoKHR {
VkStructureType sType;
const void* pNext{};
VkBool32 useMaxLevel;
StdVideoAV1Level maxLevel;
safe_VkVideoEncodeAV1SessionCreateInfoKHR(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1SessionCreateInfoKHR(const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src);
safe_VkVideoEncodeAV1SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src);
safe_VkVideoEncodeAV1SessionCreateInfoKHR();
~safe_VkVideoEncodeAV1SessionCreateInfoKHR();
void initialize(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1SessionCreateInfoKHR*>(this); }
VkVideoEncodeAV1SessionCreateInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1SessionCreateInfoKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR {
VkStructureType sType;
const void* pNext{};
const StdVideoAV1SequenceHeader* pStdSequenceHeader{};
const StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo{};
uint32_t stdOperatingPointCount;
const StdVideoEncodeAV1OperatingPointInfo* pStdOperatingPoints{};
safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src);
safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& operator=(
const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src);
safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR();
~safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR();
void initialize(const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1SessionParametersCreateInfoKHR* ptr() {
return reinterpret_cast<VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(this);
}
VkVideoEncodeAV1SessionParametersCreateInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1SessionParametersCreateInfoKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1PictureInfoKHR {
VkStructureType sType;
const void* pNext{};
VkVideoEncodeAV1PredictionModeKHR predictionMode;
VkVideoEncodeAV1RateControlGroupKHR rateControlGroup;
uint32_t constantQIndex;
const StdVideoEncodeAV1PictureInfo* pStdPictureInfo{};
int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
VkBool32 primaryReferenceCdfOnly;
VkBool32 generateObuExtensionHeader;
safe_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeAV1PictureInfoKHR(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src);
safe_VkVideoEncodeAV1PictureInfoKHR& operator=(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src);
safe_VkVideoEncodeAV1PictureInfoKHR();
~safe_VkVideoEncodeAV1PictureInfoKHR();
void initialize(const VkVideoEncodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1PictureInfoKHR*>(this); }
VkVideoEncodeAV1PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1PictureInfoKHR const*>(this); }
};
struct safe_VkVideoEncodeAV1DpbSlotInfoKHR {
VkStructureType sType;
const void* pNext{};
const StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo{};
safe_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeAV1DpbSlotInfoKHR(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src);
safe_VkVideoEncodeAV1DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src);
safe_VkVideoEncodeAV1DpbSlotInfoKHR();
~safe_VkVideoEncodeAV1DpbSlotInfoKHR();
void initialize(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1DpbSlotInfoKHR*>(this); }
VkVideoEncodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1DpbSlotInfoKHR const*>(this); }
};
struct safe_VkVideoEncodeAV1ProfileInfoKHR {
VkStructureType sType;
const void* pNext{};
StdVideoAV1Profile stdProfile;
safe_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeAV1ProfileInfoKHR(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src);
safe_VkVideoEncodeAV1ProfileInfoKHR& operator=(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src);
safe_VkVideoEncodeAV1ProfileInfoKHR();
~safe_VkVideoEncodeAV1ProfileInfoKHR();
void initialize(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1ProfileInfoKHR*>(this); }
VkVideoEncodeAV1ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1ProfileInfoKHR const*>(this); }
};
struct safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR {
VkStructureType sType;
const void* pNext{};
VkBool32 useGopRemainingFrames;
uint32_t gopRemainingIntra;
uint32_t gopRemainingPredictive;
uint32_t gopRemainingBipredictive;
safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src);
safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src);
safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR();
~safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR();
void initialize(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(this); }
VkVideoEncodeAV1GopRemainingFrameInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1GopRemainingFrameInfoKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1RateControlInfoKHR {
VkStructureType sType;
const void* pNext{};
VkVideoEncodeAV1RateControlFlagsKHR flags;
uint32_t gopFrameCount;
uint32_t keyFramePeriod;
uint32_t consecutiveBipredictiveFrameCount;
uint32_t temporalLayerCount;
safe_VkVideoEncodeAV1RateControlInfoKHR(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeAV1RateControlInfoKHR(const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src);
safe_VkVideoEncodeAV1RateControlInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src);
safe_VkVideoEncodeAV1RateControlInfoKHR();
~safe_VkVideoEncodeAV1RateControlInfoKHR();
void initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1RateControlInfoKHR*>(this); }
VkVideoEncodeAV1RateControlInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1RateControlInfoKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR {
VkStructureType sType;
const void* pNext{};
VkBool32 useMinQIndex;
VkVideoEncodeAV1QIndexKHR minQIndex;
VkBool32 useMaxQIndex;
VkVideoEncodeAV1QIndexKHR maxQIndex;
VkBool32 useMaxFrameSize;
VkVideoEncodeAV1FrameSizeKHR maxFrameSize;
safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src);
safe_VkVideoEncodeAV1RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src);
safe_VkVideoEncodeAV1RateControlLayerInfoKHR();
~safe_VkVideoEncodeAV1RateControlLayerInfoKHR();
void initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR*>(this); }
VkVideoEncodeAV1RateControlLayerInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR const*>(this);
}
};
struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
VkStructureType sType; VkStructureType sType;
void* pNext{}; void* pNext{};
@ -8661,6 +8913,217 @@ struct safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this); return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
} }
}; };
struct safe_VkVideoEncodeQuantizationMapCapabilitiesKHR {
VkStructureType sType;
void* pNext{};
VkExtent2D maxQuantizationMapExtent;
safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& operator=(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeQuantizationMapCapabilitiesKHR();
~safe_VkVideoEncodeQuantizationMapCapabilitiesKHR();
void initialize(const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeQuantizationMapCapabilitiesKHR* ptr() {
return reinterpret_cast<VkVideoEncodeQuantizationMapCapabilitiesKHR*>(this);
}
VkVideoEncodeQuantizationMapCapabilitiesKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeQuantizationMapCapabilitiesKHR const*>(this);
}
};
struct safe_VkVideoFormatQuantizationMapPropertiesKHR {
VkStructureType sType;
void* pNext{};
VkExtent2D quantizationMapTexelSize;
safe_VkVideoFormatQuantizationMapPropertiesKHR(const VkVideoFormatQuantizationMapPropertiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoFormatQuantizationMapPropertiesKHR(const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatQuantizationMapPropertiesKHR& operator=(const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatQuantizationMapPropertiesKHR();
~safe_VkVideoFormatQuantizationMapPropertiesKHR();
void initialize(const VkVideoFormatQuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoFormatQuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoFormatQuantizationMapPropertiesKHR* ptr() { return reinterpret_cast<VkVideoFormatQuantizationMapPropertiesKHR*>(this); }
VkVideoFormatQuantizationMapPropertiesKHR const* ptr() const {
return reinterpret_cast<VkVideoFormatQuantizationMapPropertiesKHR const*>(this);
}
};
struct safe_VkVideoEncodeQuantizationMapInfoKHR {
VkStructureType sType;
const void* pNext{};
VkImageView quantizationMap;
VkExtent2D quantizationMapExtent;
safe_VkVideoEncodeQuantizationMapInfoKHR(const VkVideoEncodeQuantizationMapInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeQuantizationMapInfoKHR(const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src);
safe_VkVideoEncodeQuantizationMapInfoKHR& operator=(const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src);
safe_VkVideoEncodeQuantizationMapInfoKHR();
~safe_VkVideoEncodeQuantizationMapInfoKHR();
void initialize(const VkVideoEncodeQuantizationMapInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeQuantizationMapInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeQuantizationMapInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeQuantizationMapInfoKHR*>(this); }
VkVideoEncodeQuantizationMapInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeQuantizationMapInfoKHR const*>(this);
}
};
struct safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
VkStructureType sType;
const void* pNext{};
VkExtent2D quantizationMapTexelSize;
safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src);
safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& operator=(
const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src);
safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR();
~safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR();
void initialize(const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* copy_src,
PNextCopyState* copy_state = {});
VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* ptr() {
return reinterpret_cast<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(this);
}
VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const*>(this);
}
};
struct safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
VkStructureType sType;
void* pNext{};
VkBool32 videoEncodeQuantizationMap;
safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src);
safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& operator=(
const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src);
safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR();
~safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR();
void initialize(const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* ptr() {
return reinterpret_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(this);
}
VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const*>(this);
}
};
struct safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
VkStructureType sType;
void* pNext{};
int32_t minQpDelta;
int32_t maxQpDelta;
safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& operator=(
const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR();
~safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR();
void initialize(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeH264QuantizationMapCapabilitiesKHR* ptr() {
return reinterpret_cast<VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(this);
}
VkVideoEncodeH264QuantizationMapCapabilitiesKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeH264QuantizationMapCapabilitiesKHR const*>(this);
}
};
struct safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
VkStructureType sType;
void* pNext{};
int32_t minQpDelta;
int32_t maxQpDelta;
safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& operator=(
const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR();
~safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR();
void initialize(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeH265QuantizationMapCapabilitiesKHR* ptr() {
return reinterpret_cast<VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(this);
}
VkVideoEncodeH265QuantizationMapCapabilitiesKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeH265QuantizationMapCapabilitiesKHR const*>(this);
}
};
struct safe_VkVideoFormatH265QuantizationMapPropertiesKHR {
VkStructureType sType;
void* pNext{};
VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes;
safe_VkVideoFormatH265QuantizationMapPropertiesKHR(const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoFormatH265QuantizationMapPropertiesKHR(const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatH265QuantizationMapPropertiesKHR& operator=(
const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatH265QuantizationMapPropertiesKHR();
~safe_VkVideoFormatH265QuantizationMapPropertiesKHR();
void initialize(const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoFormatH265QuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoFormatH265QuantizationMapPropertiesKHR* ptr() {
return reinterpret_cast<VkVideoFormatH265QuantizationMapPropertiesKHR*>(this);
}
VkVideoFormatH265QuantizationMapPropertiesKHR const* ptr() const {
return reinterpret_cast<VkVideoFormatH265QuantizationMapPropertiesKHR const*>(this);
}
};
struct safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
VkStructureType sType;
void* pNext{};
int32_t minQIndexDelta;
int32_t maxQIndexDelta;
safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& operator=(
const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src);
safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR();
~safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR();
void initialize(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* ptr() {
return reinterpret_cast<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(this);
}
VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const* ptr() const {
return reinterpret_cast<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const*>(this);
}
};
struct safe_VkVideoFormatAV1QuantizationMapPropertiesKHR {
VkStructureType sType;
void* pNext{};
VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes;
safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& operator=(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src);
safe_VkVideoFormatAV1QuantizationMapPropertiesKHR();
~safe_VkVideoFormatAV1QuantizationMapPropertiesKHR();
void initialize(const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
VkVideoFormatAV1QuantizationMapPropertiesKHR* ptr() {
return reinterpret_cast<VkVideoFormatAV1QuantizationMapPropertiesKHR*>(this);
}
VkVideoFormatAV1QuantizationMapPropertiesKHR const* ptr() const {
return reinterpret_cast<VkVideoFormatAV1QuantizationMapPropertiesKHR const*>(this);
}
};
struct safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR { struct safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
VkStructureType sType; VkStructureType sType;
void* pNext{}; void* pNext{};
@ -9031,6 +9494,24 @@ struct safe_VkCuModuleCreateInfoNVX {
VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleCreateInfoNVX*>(this); } VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleCreateInfoNVX*>(this); }
VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuModuleCreateInfoNVX const*>(this); } VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuModuleCreateInfoNVX const*>(this); }
}; };
struct safe_VkCuModuleTexturingModeCreateInfoNVX {
VkStructureType sType;
const void* pNext{};
VkBool32 use64bitTexturing;
safe_VkCuModuleTexturingModeCreateInfoNVX(const VkCuModuleTexturingModeCreateInfoNVX* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkCuModuleTexturingModeCreateInfoNVX(const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src);
safe_VkCuModuleTexturingModeCreateInfoNVX& operator=(const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src);
safe_VkCuModuleTexturingModeCreateInfoNVX();
~safe_VkCuModuleTexturingModeCreateInfoNVX();
void initialize(const VkCuModuleTexturingModeCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkCuModuleTexturingModeCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
VkCuModuleTexturingModeCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX*>(this); }
VkCuModuleTexturingModeCreateInfoNVX const* ptr() const {
return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX const*>(this);
}
};
struct safe_VkCuFunctionCreateInfoNVX { struct safe_VkCuFunctionCreateInfoNVX {
VkStructureType sType; VkStructureType sType;
const void* pNext{}; const void* pNext{};
@ -18326,6 +18807,40 @@ struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this); return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
} }
}; };
struct safe_VkDisplaySurfaceStereoCreateInfoNV {
VkStructureType sType;
const void* pNext{};
VkDisplaySurfaceStereoTypeNV stereoType;
safe_VkDisplaySurfaceStereoCreateInfoNV(const VkDisplaySurfaceStereoCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkDisplaySurfaceStereoCreateInfoNV(const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src);
safe_VkDisplaySurfaceStereoCreateInfoNV& operator=(const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src);
safe_VkDisplaySurfaceStereoCreateInfoNV();
~safe_VkDisplaySurfaceStereoCreateInfoNV();
void initialize(const VkDisplaySurfaceStereoCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkDisplaySurfaceStereoCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
VkDisplaySurfaceStereoCreateInfoNV* ptr() { return reinterpret_cast<VkDisplaySurfaceStereoCreateInfoNV*>(this); }
VkDisplaySurfaceStereoCreateInfoNV const* ptr() const {
return reinterpret_cast<VkDisplaySurfaceStereoCreateInfoNV const*>(this);
}
};
struct safe_VkDisplayModeStereoPropertiesNV {
VkStructureType sType;
const void* pNext{};
VkBool32 hdmi3DSupported;
safe_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkDisplayModeStereoPropertiesNV(const safe_VkDisplayModeStereoPropertiesNV& copy_src);
safe_VkDisplayModeStereoPropertiesNV& operator=(const safe_VkDisplayModeStereoPropertiesNV& copy_src);
safe_VkDisplayModeStereoPropertiesNV();
~safe_VkDisplayModeStereoPropertiesNV();
void initialize(const VkDisplayModeStereoPropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkDisplayModeStereoPropertiesNV* copy_src, PNextCopyState* copy_state = {});
VkDisplayModeStereoPropertiesNV* ptr() { return reinterpret_cast<VkDisplayModeStereoPropertiesNV*>(this); }
VkDisplayModeStereoPropertiesNV const* ptr() const { return reinterpret_cast<VkDisplayModeStereoPropertiesNV const*>(this); }
};
struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV { struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
VkStructureType sType; VkStructureType sType;
void* pNext{}; void* pNext{};
@ -18947,6 +19462,28 @@ struct safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV const*>(this); return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV const*>(this);
} }
}; };
struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
VkStructureType sType;
void* pNext{};
VkBool32 vertexAttributeRobustness;
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src);
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& operator=(
const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src);
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT();
~safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT();
void initialize(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* ptr() {
return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(this);
}
VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const*>(this);
}
};
struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext{}; const void* pNext{};

25
include/vulkan/utility/vk_struct_helper.hpp
View file

@ -439,6 +439,17 @@ template <> inline VkStructureType GetSType<VkVideoDecodeAV1CapabilitiesKHR>() {
template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; } template <> inline VkStructureType GetSType<VkVideoDecodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; } template <> inline VkStructureType GetSType<VkVideoDecodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1QualityLevelPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1GopRemainingFrameInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; } template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
@ -460,6 +471,16 @@ template <> inline VkStructureType GetSType<VkPushDescriptorSetInfoKHR>() { retu
template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; } template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; } 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<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
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; }
template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoFormatH265QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoFormatAV1QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; } template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; }
@ -478,6 +499,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackFea
template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; } template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; }
template <> inline VkStructureType GetSType<VkPipelineRasterizationStateStreamCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType<VkPipelineRasterizationStateStreamCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkCuModuleCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; } template <> inline VkStructureType GetSType<VkCuModuleCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; }
template <> inline VkStructureType GetSType<VkCuModuleTexturingModeCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; }
template <> inline VkStructureType GetSType<VkCuFunctionCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; } template <> inline VkStructureType GetSType<VkCuFunctionCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; }
template <> inline VkStructureType GetSType<VkCuLaunchInfoNVX>() { return VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; } template <> inline VkStructureType GetSType<VkCuLaunchInfoNVX>() { return VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; }
template <> inline VkStructureType GetSType<VkImageViewHandleInfoNVX>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; } template <> inline VkStructureType GetSType<VkImageViewHandleInfoNVX>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; }
@ -961,6 +983,8 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
#endif // VK_USE_PLATFORM_SCREEN_QNX #endif // VK_USE_PLATFORM_SCREEN_QNX
template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; } template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
@ -990,6 +1014,7 @@ template <> inline VkStructureType GetSType<VkHdrVividDynamicMetadataHUAWEI>() {
template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; } template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; } template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; } 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<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; } template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }

286
include/vulkan/vk_enum_string_helper.h
View file

@ -652,6 +652,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"; return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX";
case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"; return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX";
case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
return "VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX";
case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"; return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX";
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
@ -1864,6 +1866,28 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR"; return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR"; return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR"; return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
@ -1942,6 +1966,30 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT"; return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV"; return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
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_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR";
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV"; return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
@ -2012,6 +2060,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV"; return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV"; return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
default: default:
return "Unhandled VkStructureType"; return "Unhandled VkStructureType";
} }
@ -2084,6 +2134,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"; return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT"; return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
default: default:
return "Unhandled VkImageLayout"; return "Unhandled VkImageLayout";
} }
@ -3906,6 +3958,32 @@ static inline const char* string_VkScopeKHR(VkScopeKHR input_value) {
return "Unhandled VkScopeKHR"; return "Unhandled VkScopeKHR";
} }
} }
static inline const char* string_VkVideoEncodeAV1PredictionModeKHR(VkVideoEncodeAV1PredictionModeKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR:
return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR";
case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR:
return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR";
case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR:
return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR";
case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR:
return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR";
default:
return "Unhandled VkVideoEncodeAV1PredictionModeKHR";
}
}
static inline const char* string_VkVideoEncodeAV1RateControlGroupKHR(VkVideoEncodeAV1RateControlGroupKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR";
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR";
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR";
default:
return "Unhandled VkVideoEncodeAV1RateControlGroupKHR";
}
}
static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) { static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) {
switch (input_value) { switch (input_value) {
case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR:
@ -4918,6 +4996,20 @@ static inline const char* string_VkLayeredDriverUnderlyingApiMSFT(VkLayeredDrive
return "Unhandled VkLayeredDriverUnderlyingApiMSFT"; return "Unhandled VkLayeredDriverUnderlyingApiMSFT";
} }
} }
static inline const char* string_VkDisplaySurfaceStereoTypeNV(VkDisplaySurfaceStereoTypeNV input_value) {
switch (input_value) {
case VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV:
return "VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV";
case VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV:
return "VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV";
case VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV:
return "VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV";
case VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV:
return "VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV";
default:
return "Unhandled VkDisplaySurfaceStereoTypeNV";
}
}
static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) { static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) {
switch (input_value) { switch (input_value) {
case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
@ -5346,6 +5438,10 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM"; return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM"; return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
return "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
case VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR:
return "VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
default: default:
return "Unhandled VkImageUsageFlagBits"; return "Unhandled VkImageUsageFlagBits";
} }
@ -7439,6 +7535,8 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV";
if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV";
if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV";
if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
return "Unhandled VkFormatFeatureFlagBits2"; return "Unhandled VkFormatFeatureFlagBits2";
} }
@ -7637,6 +7735,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp
return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"; return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR";
case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"; return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
return "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR";
default: default:
return "Unhandled VkVideoCodecOperationFlagBitsKHR"; return "Unhandled VkVideoCodecOperationFlagBitsKHR";
} }
@ -7757,6 +7857,10 @@ static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionC
return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"; return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR";
case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR:
return "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"; return "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR";
case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR:
return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR";
default: default:
return "Unhandled VkVideoSessionCreateFlagBitsKHR"; return "Unhandled VkVideoSessionCreateFlagBitsKHR";
} }
@ -7778,6 +7882,31 @@ static inline std::string string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCrea
return ret; return ret;
} }
#endif // __cplusplus #endif // __cplusplus
static inline const char* string_VkVideoSessionParametersCreateFlagBitsKHR(VkVideoSessionParametersCreateFlagBitsKHR input_value) {
switch (input_value) {
case VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR:
return "VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR";
default:
return "Unhandled VkVideoSessionParametersCreateFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoSessionParametersCreateFlagsKHR(VkVideoSessionParametersCreateFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoSessionParametersCreateFlagBitsKHR(static_cast<VkVideoSessionParametersCreateFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoSessionParametersCreateFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value) { static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value) {
switch (input_value) { switch (input_value) {
case VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR: case VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR:
@ -7885,6 +8014,8 @@ static inline const char* string_VkVideoEncodeH264CapabilityFlagBitsKHR(VkVideoE
return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"; return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR";
case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR:
return "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_MB_QP_DIFF_WRAPAROUND_BIT_KHR:
return "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR";
default: default:
return "Unhandled VkVideoEncodeH264CapabilityFlagBitsKHR"; return "Unhandled VkVideoEncodeH264CapabilityFlagBitsKHR";
} }
@ -8024,6 +8155,8 @@ static inline const char* string_VkVideoEncodeH265CapabilityFlagBitsKHR(VkVideoE
return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"; 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: 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"; return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_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: default:
return "Unhandled VkVideoEncodeH265CapabilityFlagBitsKHR"; return "Unhandled VkVideoEncodeH265CapabilityFlagBitsKHR";
} }
@ -8284,12 +8417,43 @@ static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR inp
return ret; return ret;
} }
#endif // __cplusplus #endif // __cplusplus
static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value) {
switch (input_value) {
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:
return "VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR";
default:
return "Unhandled VkVideoEncodeFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoEncodeFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value) { static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value) {
switch (input_value) { switch (input_value) {
case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR:
return "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR"; return "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR";
case VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: case VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR:
return "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR"; return "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR";
case VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR:
return "VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR";
case VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR:
return "VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR";
default: default:
return "Unhandled VkVideoEncodeCapabilityFlagBitsKHR"; return "Unhandled VkVideoEncodeCapabilityFlagBitsKHR";
} }
@ -8541,6 +8705,128 @@ static inline std::string string_VkBufferUsageFlags2KHR(VkBufferUsageFlags2KHR i
return ret; return ret;
} }
#endif // __cplusplus #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:
return "VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR:
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";
default:
return "Unhandled VkVideoEncodeAV1CapabilityFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoEncodeAV1CapabilityFlagsKHR(VkVideoEncodeAV1CapabilityFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoEncodeAV1CapabilityFlagBitsKHR(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoEncodeAV1CapabilityFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkVideoEncodeAV1StdFlagBitsKHR(VkVideoEncodeAV1StdFlagBitsKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR";
default:
return "Unhandled VkVideoEncodeAV1StdFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoEncodeAV1StdFlagsKHR(VkVideoEncodeAV1StdFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoEncodeAV1StdFlagBitsKHR(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoEncodeAV1StdFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR";
default:
return "Unhandled VkVideoEncodeAV1SuperblockSizeFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoEncodeAV1SuperblockSizeFlagsKHR(VkVideoEncodeAV1SuperblockSizeFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoEncodeAV1SuperblockSizeFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkVideoEncodeAV1RateControlFlagBitsKHR(VkVideoEncodeAV1RateControlFlagBitsKHR input_value) {
switch (input_value) {
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR";
case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR:
return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR";
default:
return "Unhandled VkVideoEncodeAV1RateControlFlagBitsKHR";
}
}
#ifdef __cplusplus
static inline std::string string_VkVideoEncodeAV1RateControlFlagsKHR(VkVideoEncodeAV1RateControlFlagsKHR input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkVideoEncodeAV1RateControlFlagBitsKHR(static_cast<VkVideoEncodeAV1RateControlFlagBitsKHR>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkVideoEncodeAV1RateControlFlagsKHR(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value) { static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value) {
switch (input_value) { switch (input_value) {
case VK_DEBUG_REPORT_INFORMATION_BIT_EXT: case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:

2
scripts/known_good.json
View file

@ -7,7 +7,7 @@
"sub_dir": "Vulkan-Headers", "sub_dir": "Vulkan-Headers",
"build_dir": "Vulkan-Headers/build", "build_dir": "Vulkan-Headers/build",
"install_dir": "Vulkan-Headers/build/install", "install_dir": "Vulkan-Headers/build/install",
"commit": "v1.3.301" "commit": "v1.3.302"
}, },
{ {
"name": "googletest", "name": "googletest",

53
src/vulkan/vk_safe_struct_ext.cpp
View file

@ -16647,6 +16647,59 @@ void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize(
} }
} }
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
: sType(in_struct->sType), vertexAttributeRobustness(in_struct->vertexAttributeRobustness) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT),
pNext(nullptr),
vertexAttributeRobustness() {}
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src) {
sType = copy_src.sType;
vertexAttributeRobustness = copy_src.vertexAttributeRobustness;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::operator=(
const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
vertexAttributeRobustness = copy_src.vertexAttributeRobustness;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::~safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT() {
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::initialize(
const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
vertexAttributeRobustness = in_struct->vertexAttributeRobustness;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::initialize(
const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
vertexAttributeRobustness = copy_src->vertexAttributeRobustness;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT( safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), : sType(in_struct->sType),

1562
src/vulkan/vk_safe_struct_khr.cpp
View file

File diff suppressed because it is too large Load diff

150
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -737,6 +737,39 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
safe_pNext = new safe_VkVideoDecodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkVideoDecodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeAV1CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
safe_pNext = new safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1PictureInfoKHR(reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeAV1RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
break; break;
@ -779,6 +812,36 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
break; 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;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
safe_pNext = new safe_VkVideoFormatQuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeQuantizationMapInfoKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
safe_pNext = new safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
safe_pNext = new safe_VkVideoFormatH265QuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
safe_pNext = new safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext), copy_state, false);
break; break;
@ -818,6 +881,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext), copy_state, false); safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
safe_pNext = new safe_VkCuModuleTexturingModeCreateInfoNVX(reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext), copy_state, false); safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext), copy_state, false);
break; break;
@ -1828,6 +1894,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
safe_pNext = new safe_VkDisplaySurfaceStereoCreateInfoNV(reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
safe_pNext = new safe_VkDisplayModeStereoPropertiesNV(reinterpret_cast<const VkDisplayModeStereoPropertiesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
break; break;
@ -1882,6 +1954,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(pNext), copy_state, false); safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(pNext), copy_state, false);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false); safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
break; break;
@ -2635,6 +2710,39 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
delete reinterpret_cast<safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header); delete reinterpret_cast<safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1CapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1QualityLevelPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1SessionCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1PictureInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1DpbSlotInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1ProfileInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1RateControlInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1RateControlLayerInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
break; break;
@ -2677,6 +2785,36 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header); delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header);
break; break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkVideoFormatQuantizationMapPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkVideoFormatH265QuantizationMapPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkVideoFormatAV1QuantizationMapPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header);
break; break;
@ -2716,6 +2854,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
delete reinterpret_cast<safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header); delete reinterpret_cast<safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
break; break;
case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
delete reinterpret_cast<safe_VkCuModuleTexturingModeCreateInfoNVX *>(header);
break;
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
delete reinterpret_cast<safe_VkTextureLODGatherFormatPropertiesAMD *>(header); delete reinterpret_cast<safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
break; break;
@ -3726,6 +3867,12 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
break; break;
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkDisplaySurfaceStereoCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
delete reinterpret_cast<safe_VkDisplayModeStereoPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
break; break;
@ -3780,6 +3927,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header); delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header);
break; break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header); delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
break; break;

144
src/vulkan/vk_safe_struct_vendor.cpp
View file

@ -309,6 +309,54 @@ void safe_VkCuModuleCreateInfoNVX::initialize(const safe_VkCuModuleCreateInfoNVX
} }
} }
safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX(
const VkCuModuleTexturingModeCreateInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), use64bitTexturing(in_struct->use64bitTexturing) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX()
: sType(VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX), pNext(nullptr), use64bitTexturing() {}
safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX(
const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src) {
sType = copy_src.sType;
use64bitTexturing = copy_src.use64bitTexturing;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkCuModuleTexturingModeCreateInfoNVX& safe_VkCuModuleTexturingModeCreateInfoNVX::operator=(
const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
use64bitTexturing = copy_src.use64bitTexturing;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkCuModuleTexturingModeCreateInfoNVX::~safe_VkCuModuleTexturingModeCreateInfoNVX() { FreePnextChain(pNext); }
void safe_VkCuModuleTexturingModeCreateInfoNVX::initialize(const VkCuModuleTexturingModeCreateInfoNVX* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
use64bitTexturing = in_struct->use64bitTexturing;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkCuModuleTexturingModeCreateInfoNVX::initialize(const safe_VkCuModuleTexturingModeCreateInfoNVX* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
use64bitTexturing = copy_src->use64bitTexturing;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), module(in_struct->module) { : sType(in_struct->sType), module(in_struct->module) {
@ -15111,6 +15159,102 @@ void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
pNext = SafePnextCopy(copy_src->pNext); pNext = SafePnextCopy(copy_src->pNext);
} }
safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV(
const VkDisplaySurfaceStereoCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), stereoType(in_struct->stereoType) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV()
: sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV), pNext(nullptr), stereoType() {}
safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV(
const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src) {
sType = copy_src.sType;
stereoType = copy_src.stereoType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplaySurfaceStereoCreateInfoNV& safe_VkDisplaySurfaceStereoCreateInfoNV::operator=(
const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
stereoType = copy_src.stereoType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplaySurfaceStereoCreateInfoNV::~safe_VkDisplaySurfaceStereoCreateInfoNV() { FreePnextChain(pNext); }
void safe_VkDisplaySurfaceStereoCreateInfoNV::initialize(const VkDisplaySurfaceStereoCreateInfoNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
stereoType = in_struct->stereoType;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkDisplaySurfaceStereoCreateInfoNV::initialize(const safe_VkDisplaySurfaceStereoCreateInfoNV* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
stereoType = copy_src->stereoType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
: sType(in_struct->sType), hdmi3DSupported(in_struct->hdmi3DSupported) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV()
: sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV), pNext(nullptr), hdmi3DSupported() {}
safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV(const safe_VkDisplayModeStereoPropertiesNV& copy_src) {
sType = copy_src.sType;
hdmi3DSupported = copy_src.hdmi3DSupported;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDisplayModeStereoPropertiesNV& safe_VkDisplayModeStereoPropertiesNV::operator=(
const safe_VkDisplayModeStereoPropertiesNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
hdmi3DSupported = copy_src.hdmi3DSupported;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDisplayModeStereoPropertiesNV::~safe_VkDisplayModeStereoPropertiesNV() { FreePnextChain(pNext); }
void safe_VkDisplayModeStereoPropertiesNV::initialize(const VkDisplayModeStereoPropertiesNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
hdmi3DSupported = in_struct->hdmi3DSupported;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkDisplayModeStereoPropertiesNV::initialize(const safe_VkDisplayModeStereoPropertiesNV* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
hdmi3DSupported = copy_src->hdmi3DSupported;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV( safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(
const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), shaderRawAccessChains(in_struct->shaderRawAccessChains) { : sType(in_struct->sType), shaderRawAccessChains(in_struct->shaderRawAccessChains) {