Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

build: Update to header 1.3.285 #209

Merged
merged 1 commit into from
May 13, 2024
Merged

build: Update to header 1.3.285 #209

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 61 additions & 0 deletions include/vulkan/utility/vk_safe_struct.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17915,6 +17915,67 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
VkStructureType sType;
void* pNext{};
VkBool32 imageAlignmentControl;

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src);
safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& operator=(
const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src);
safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA();
~safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA();
void initialize(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceImageAlignmentControlFeaturesMESA* ptr() {
return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(this);
}
VkPhysicalDeviceImageAlignmentControlFeaturesMESA const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA const*>(this);
}
};
struct safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
VkStructureType sType;
void* pNext{};
uint32_t supportedImageAlignmentMask;

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src);
safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& operator=(
const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src);
safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA();
~safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA();
void initialize(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceImageAlignmentControlPropertiesMESA* ptr() {
return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(this);
}
VkPhysicalDeviceImageAlignmentControlPropertiesMESA const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlPropertiesMESA const*>(this);
}
};
struct safe_VkImageAlignmentControlCreateInfoMESA {
VkStructureType sType;
const void* pNext{};
uint32_t maximumRequestedAlignment;

safe_VkImageAlignmentControlCreateInfoMESA(const VkImageAlignmentControlCreateInfoMESA* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkImageAlignmentControlCreateInfoMESA(const safe_VkImageAlignmentControlCreateInfoMESA& copy_src);
safe_VkImageAlignmentControlCreateInfoMESA& operator=(const safe_VkImageAlignmentControlCreateInfoMESA& copy_src);
safe_VkImageAlignmentControlCreateInfoMESA();
~safe_VkImageAlignmentControlCreateInfoMESA();
void initialize(const VkImageAlignmentControlCreateInfoMESA* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkImageAlignmentControlCreateInfoMESA* copy_src, PNextCopyState* copy_state = {});
VkImageAlignmentControlCreateInfoMESA* ptr() { return reinterpret_cast<VkImageAlignmentControlCreateInfoMESA*>(this); }
VkImageAlignmentControlCreateInfoMESA const* ptr() const {
return reinterpret_cast<VkImageAlignmentControlCreateInfoMESA const*>(this);
}
};
struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
VkStructureType sType;
const void* pNext{};
Expand Down
3 changes: 3 additions & 0 deletions include/vulkan/utility/vk_struct_helper.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -943,6 +943,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOveral
template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlPropertiesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }
template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
Expand Down
6 changes: 6 additions & 0 deletions include/vulkan/vk_enum_string_helper.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1914,6 +1914,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA";
case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
return "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA";
default:
return "Unhandled VkStructureType";
}
Expand Down
2 changes: 1 addition & 1 deletion scripts/known_good.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@
"sub_dir": "Vulkan-Headers",
"build_dir": "Vulkan-Headers/build",
"install_dir": "Vulkan-Headers/build/install",
"commit": "v1.3.284"
"commit": "v1.3.285"
},
{
"name": "googletest",
Expand Down
18 changes: 18 additions & 0 deletions src/vulkan/vk_safe_struct_utils.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1794,6 +1794,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
safe_pNext = new safe_VkImageAlignmentControlCreateInfoMESA(reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
break;
Expand Down Expand Up @@ -3596,6 +3605,15 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(header);
break;
case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
delete reinterpret_cast<const safe_VkImageAlignmentControlCreateInfoMESA *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
break;
Expand Down
152 changes: 152 additions & 0 deletions src/vulkan/vk_safe_struct_vendor.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15118,6 +15118,158 @@ void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize(
pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(
const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
: sType(in_struct->sType), imageAlignmentControl(in_struct->imageAlignmentControl) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA), pNext(nullptr), imageAlignmentControl() {}

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(
const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src) {
sType = copy_src.sType;
imageAlignmentControl = copy_src.imageAlignmentControl;
pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::operator=(
const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src) {
if (&copy_src == this) return *this;

FreePnextChain(pNext);

sType = copy_src.sType;
imageAlignmentControl = copy_src.imageAlignmentControl;
pNext = SafePnextCopy(copy_src.pNext);

return *this;
}

safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::~safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA() {
FreePnextChain(pNext);
}

void safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::initialize(
const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
imageAlignmentControl = in_struct->imageAlignmentControl;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::initialize(
const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
imageAlignmentControl = copy_src->imageAlignmentControl;
pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)
: sType(in_struct->sType), supportedImageAlignmentMask(in_struct->supportedImageAlignmentMask) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA),
pNext(nullptr),
supportedImageAlignmentMask() {}

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src) {
sType = copy_src.sType;
supportedImageAlignmentMask = copy_src.supportedImageAlignmentMask;
pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::operator=(
const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src) {
if (&copy_src == this) return *this;

FreePnextChain(pNext);

sType = copy_src.sType;
supportedImageAlignmentMask = copy_src.supportedImageAlignmentMask;
pNext = SafePnextCopy(copy_src.pNext);

return *this;
}

safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::~safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA() {
FreePnextChain(pNext);
}

void safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::initialize(
const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
supportedImageAlignmentMask = in_struct->supportedImageAlignmentMask;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::initialize(
const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
supportedImageAlignmentMask = copy_src->supportedImageAlignmentMask;
pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA(
const VkImageAlignmentControlCreateInfoMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), maximumRequestedAlignment(in_struct->maximumRequestedAlignment) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}

safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA()
: sType(VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA), pNext(nullptr), maximumRequestedAlignment() {}

safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA(
const safe_VkImageAlignmentControlCreateInfoMESA& copy_src) {
sType = copy_src.sType;
maximumRequestedAlignment = copy_src.maximumRequestedAlignment;
pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkImageAlignmentControlCreateInfoMESA& safe_VkImageAlignmentControlCreateInfoMESA::operator=(
const safe_VkImageAlignmentControlCreateInfoMESA& copy_src) {
if (&copy_src == this) return *this;

FreePnextChain(pNext);

sType = copy_src.sType;
maximumRequestedAlignment = copy_src.maximumRequestedAlignment;
pNext = SafePnextCopy(copy_src.pNext);

return *this;
}

safe_VkImageAlignmentControlCreateInfoMESA::~safe_VkImageAlignmentControlCreateInfoMESA() { FreePnextChain(pNext); }

void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const VkImageAlignmentControlCreateInfoMESA* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
maximumRequestedAlignment = in_struct->maximumRequestedAlignment;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const safe_VkImageAlignmentControlCreateInfoMESA* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
maximumRequestedAlignment = copy_src->maximumRequestedAlignment;
pNext = SafePnextCopy(copy_src->pNext);
}

} // namespace vku

// NOLINTEND
Loading