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

build: Update to header 1.4.313
Some checks failed
ci / reuse (push) Has been cancelled
Details
ci / generate_source (push) Has been cancelled
Details
format / clang-format (push) Has been cancelled
Details
ci / windows-arm64 (push) Has been cancelled
Details
ci / build_and_test (Debug, macos-latest) (push) Has been cancelled
Details
ci / build_and_test (Debug, ubuntu-22.04) (push) Has been cancelled
Details
ci / build_and_test (Debug, ubuntu-24.04) (push) Has been cancelled
Details
ci / build_and_test (Debug, windows-latest) (push) Has been cancelled
Details
ci / build_and_test (Release, macos-latest) (push) Has been cancelled
Details
ci / build_and_test (Release, ubuntu-22.04) (push) Has been cancelled
Details
ci / build_and_test (Release, ubuntu-24.04) (push) Has been cancelled
Details
ci / build_and_test (Release, windows-latest) (push) Has been cancelled
Details
ci / android (arm64-v8a) (push) Has been cancelled
Details
ci / android (armeabi-v7a) (push) Has been cancelled
Details
ci / chromium (push) Has been cancelled
Details

Browse source
This commit is contained in:
Mike Schuchardt 2025-04-18 11:43:41 -07:00
parent 4ee0833a3c
commit 4e246c56ec
7 changed files with 392 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

@ -767,6 +767,7 @@ typedef struct VkuDeviceDispatchTable_ {
#ifdef VK_USE_PLATFORM_SCREEN_QNX
PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
#endif // VK_USE_PLATFORM_SCREEN_QNX
PFN_vkCmdBindTileMemoryQCOM CmdBindTileMemoryQCOM;
PFN_vkCreateExternalComputeQueueNV CreateExternalComputeQueueNV;
PFN_vkDestroyExternalComputeQueueNV DestroyExternalComputeQueueNV;
PFN_vkGetExternalComputeQueueDataNV GetExternalComputeQueueDataNV;
@ -1418,6 +1419,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
#ifdef VK_USE_PLATFORM_SCREEN_QNX
table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
#endif // VK_USE_PLATFORM_SCREEN_QNX
table->CmdBindTileMemoryQCOM = (PFN_vkCmdBindTileMemoryQCOM)gdpa(device, "vkCmdBindTileMemoryQCOM");
table->CreateExternalComputeQueueNV = (PFN_vkCreateExternalComputeQueueNV)gdpa(device, "vkCreateExternalComputeQueueNV");
table->DestroyExternalComputeQueueNV = (PFN_vkDestroyExternalComputeQueueNV)gdpa(device, "vkDestroyExternalComputeQueueNV");
table->GetExternalComputeQueueDataNV = (PFN_vkGetExternalComputeQueueDataNV)gdpa(device, "vkGetExternalComputeQueueDataNV");

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

@ -19294,6 +19294,96 @@ struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
VkStructureType sType;
void* pNext{};
VkBool32 tileMemoryHeap;
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src);
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src);
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM();
~safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM();
void initialize(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* ptr() {
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(this);
}
VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const*>(this);
}
};
struct safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
VkStructureType sType;
void* pNext{};
VkBool32 queueSubmitBoundary;
VkBool32 tileBufferTransfers;
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src);
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& operator=(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src);
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM();
~safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM();
void initialize(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* ptr() {
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(this);
}
VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const*>(this);
}
};
struct safe_VkTileMemoryRequirementsQCOM {
VkStructureType sType;
void* pNext{};
VkDeviceSize size;
VkDeviceSize alignment;
safe_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkTileMemoryRequirementsQCOM(const safe_VkTileMemoryRequirementsQCOM& copy_src);
safe_VkTileMemoryRequirementsQCOM& operator=(const safe_VkTileMemoryRequirementsQCOM& copy_src);
safe_VkTileMemoryRequirementsQCOM();
~safe_VkTileMemoryRequirementsQCOM();
void initialize(const VkTileMemoryRequirementsQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkTileMemoryRequirementsQCOM* copy_src, PNextCopyState* copy_state = {});
VkTileMemoryRequirementsQCOM* ptr() { return reinterpret_cast<VkTileMemoryRequirementsQCOM*>(this); }
VkTileMemoryRequirementsQCOM const* ptr() const { return reinterpret_cast<VkTileMemoryRequirementsQCOM const*>(this); }
};
struct safe_VkTileMemoryBindInfoQCOM {
VkStructureType sType;
const void* pNext{};
VkDeviceMemory memory;
safe_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkTileMemoryBindInfoQCOM(const safe_VkTileMemoryBindInfoQCOM& copy_src);
safe_VkTileMemoryBindInfoQCOM& operator=(const safe_VkTileMemoryBindInfoQCOM& copy_src);
safe_VkTileMemoryBindInfoQCOM();
~safe_VkTileMemoryBindInfoQCOM();
void initialize(const VkTileMemoryBindInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkTileMemoryBindInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkTileMemoryBindInfoQCOM* ptr() { return reinterpret_cast<VkTileMemoryBindInfoQCOM*>(this); }
VkTileMemoryBindInfoQCOM const* ptr() const { return reinterpret_cast<VkTileMemoryBindInfoQCOM const*>(this); }
};
struct safe_VkTileMemorySizeInfoQCOM {
VkStructureType sType;
const void* pNext{};
VkDeviceSize size;
safe_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkTileMemorySizeInfoQCOM(const safe_VkTileMemorySizeInfoQCOM& copy_src);
safe_VkTileMemorySizeInfoQCOM& operator=(const safe_VkTileMemorySizeInfoQCOM& copy_src);
safe_VkTileMemorySizeInfoQCOM();
~safe_VkTileMemorySizeInfoQCOM();
void initialize(const VkTileMemorySizeInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkTileMemorySizeInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkTileMemorySizeInfoQCOM* ptr() { return reinterpret_cast<VkTileMemorySizeInfoQCOM*>(this); }
VkTileMemorySizeInfoQCOM const* ptr() const { return reinterpret_cast<VkTileMemorySizeInfoQCOM const*>(this); }
};
struct safe_VkDisplaySurfaceStereoCreateInfoNV {
VkStructureType sType;
const void* pNext{};

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

@ -1007,6 +1007,11 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
#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<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; }
template <> inline VkStructureType GetSType<VkTileMemoryRequirementsQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; }
template <> inline VkStructureType GetSType<VkTileMemoryBindInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; }
template <> inline VkStructureType GetSType<VkTileMemorySizeInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; }
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; }

17
include/vulkan/vk_enum_string_helper.h
View file

@ -1992,6 +1992,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
case 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_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM";
case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
return "VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM";
case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
return "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM";
case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
return "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM";
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:
@ -5644,6 +5654,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
case VK_IMAGE_USAGE_TILE_MEMORY_QCOM:
return "VK_IMAGE_USAGE_TILE_MEMORY_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:
@ -5700,6 +5712,8 @@ static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input
return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT:
return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
case VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM:
return "VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM";
default:
return "Unhandled VkMemoryHeapFlagBits";
}
@ -6209,6 +6223,8 @@ static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits inp
return "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
case VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT:
return "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT";
case VK_BUFFER_USAGE_TILE_MEMORY_QCOM:
return "VK_BUFFER_USAGE_TILE_MEMORY_QCOM";
default:
return "Unhandled VkBufferUsageFlagBits";
}
@ -7891,6 +7907,7 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) {
if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
if (input_value == VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM) return "VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM";
if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
return "Unhandled VkBufferUsageFlagBits2";
}

2
scripts/known_good.json
View file

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

30
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -1947,6 +1947,21 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
safe_pNext = new safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
safe_pNext = new safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
safe_pNext = new safe_VkTileMemoryRequirementsQCOM(reinterpret_cast<const VkTileMemoryRequirementsQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
safe_pNext = new safe_VkTileMemoryBindInfoQCOM(reinterpret_cast<const VkTileMemoryBindInfoQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
safe_pNext = new safe_VkTileMemorySizeInfoQCOM(reinterpret_cast<const VkTileMemorySizeInfoQCOM *>(pNext), copy_state, false);
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;
@ -4016,6 +4031,21 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
delete reinterpret_cast<safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
delete reinterpret_cast<safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
delete reinterpret_cast<safe_VkTileMemoryRequirementsQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
delete reinterpret_cast<safe_VkTileMemoryBindInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
delete reinterpret_cast<safe_VkTileMemorySizeInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkDisplaySurfaceStereoCreateInfoNV *>(header);
break;

247
src/vulkan/vk_safe_struct_vendor.cpp
View file

@ -15948,6 +15948,253 @@ void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(
const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), tileMemoryHeap(in_struct->tileMemoryHeap) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM), pNext(nullptr), tileMemoryHeap() {}
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(
const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src) {
sType = copy_src.sType;
tileMemoryHeap = copy_src.tileMemoryHeap;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::operator=(
const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
tileMemoryHeap = copy_src.tileMemoryHeap;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::~safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM() { FreePnextChain(pNext); }
void safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::initialize(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
tileMemoryHeap = in_struct->tileMemoryHeap;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
tileMemoryHeap = copy_src->tileMemoryHeap;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(
const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
queueSubmitBoundary(in_struct->queueSubmitBoundary),
tileBufferTransfers(in_struct->tileBufferTransfers) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM),
pNext(nullptr),
queueSubmitBoundary(),
tileBufferTransfers() {}
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(
const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src) {
sType = copy_src.sType;
queueSubmitBoundary = copy_src.queueSubmitBoundary;
tileBufferTransfers = copy_src.tileBufferTransfers;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::operator=(
const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
queueSubmitBoundary = copy_src.queueSubmitBoundary;
tileBufferTransfers = copy_src.tileBufferTransfers;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::~safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM() { FreePnextChain(pNext); }
void safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::initialize(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
queueSubmitBoundary = in_struct->queueSubmitBoundary;
tileBufferTransfers = in_struct->tileBufferTransfers;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::initialize(
const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
queueSubmitBoundary = copy_src->queueSubmitBoundary;
tileBufferTransfers = copy_src->tileBufferTransfers;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), size(in_struct->size), alignment(in_struct->alignment) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM()
: sType(VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM), pNext(nullptr), size(), alignment() {}
safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM(const safe_VkTileMemoryRequirementsQCOM& copy_src) {
sType = copy_src.sType;
size = copy_src.size;
alignment = copy_src.alignment;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkTileMemoryRequirementsQCOM& safe_VkTileMemoryRequirementsQCOM::operator=(const safe_VkTileMemoryRequirementsQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
size = copy_src.size;
alignment = copy_src.alignment;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkTileMemoryRequirementsQCOM::~safe_VkTileMemoryRequirementsQCOM() { FreePnextChain(pNext); }
void safe_VkTileMemoryRequirementsQCOM::initialize(const VkTileMemoryRequirementsQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
size = in_struct->size;
alignment = in_struct->alignment;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkTileMemoryRequirementsQCOM::initialize(const safe_VkTileMemoryRequirementsQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
size = copy_src->size;
alignment = copy_src->alignment;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), memory(in_struct->memory) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM()
: sType(VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM), pNext(nullptr), memory() {}
safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM(const safe_VkTileMemoryBindInfoQCOM& copy_src) {
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkTileMemoryBindInfoQCOM& safe_VkTileMemoryBindInfoQCOM::operator=(const safe_VkTileMemoryBindInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
memory = copy_src.memory;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkTileMemoryBindInfoQCOM::~safe_VkTileMemoryBindInfoQCOM() { FreePnextChain(pNext); }
void safe_VkTileMemoryBindInfoQCOM::initialize(const VkTileMemoryBindInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
memory = in_struct->memory;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkTileMemoryBindInfoQCOM::initialize(const safe_VkTileMemoryBindInfoQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
memory = copy_src->memory;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), size(in_struct->size) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM()
: sType(VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM), pNext(nullptr), size() {}
safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM(const safe_VkTileMemorySizeInfoQCOM& copy_src) {
sType = copy_src.sType;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkTileMemorySizeInfoQCOM& safe_VkTileMemorySizeInfoQCOM::operator=(const safe_VkTileMemorySizeInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
size = copy_src.size;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkTileMemorySizeInfoQCOM::~safe_VkTileMemorySizeInfoQCOM() { FreePnextChain(pNext); }
void safe_VkTileMemorySizeInfoQCOM::initialize(const VkTileMemorySizeInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
size = in_struct->size;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkTileMemorySizeInfoQCOM::initialize(const safe_VkTileMemorySizeInfoQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
size = copy_src->size;
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) {