build: Update to header 1.3.291

KhronosGroup · Jul 19, 2024 · 9d97d51 · 9d97d51
1 parent 9479047
commit 9d97d51
Show file tree

Hide file tree

Showing 7 changed files with 252 additions and 1 deletion.
diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
@@ -716,6 +716,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyOpticalFlowSessionNV DestroyOpticalFlowSessionNV;
     PFN_vkBindOpticalFlowSessionImageNV BindOpticalFlowSessionImageNV;
     PFN_vkCmdOpticalFlowExecuteNV CmdOpticalFlowExecuteNV;
+    PFN_vkAntiLagUpdateAMD AntiLagUpdateAMD;
     PFN_vkCreateShadersEXT CreateShadersEXT;
     PFN_vkDestroyShaderEXT DestroyShaderEXT;
     PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT;
@@ -1312,6 +1313,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)gdpa(device, "vkDestroyOpticalFlowSessionNV");
     table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV)gdpa(device, "vkBindOpticalFlowSessionImageNV");
     table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)gdpa(device, "vkCmdOpticalFlowExecuteNV");
+    table->AntiLagUpdateAMD = (PFN_vkAntiLagUpdateAMD)gdpa(device, "vkAntiLagUpdateAMD");
     table->CreateShadersEXT = (PFN_vkCreateShadersEXT)gdpa(device, "vkCreateShadersEXT");
     table->DestroyShaderEXT = (PFN_vkDestroyShaderEXT)gdpa(device, "vkDestroyShaderEXT");
     table->GetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)gdpa(device, "vkGetShaderBinaryDataEXT");

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
@@ -17001,6 +17001,58 @@ struct safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
     }
 };
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkPhysicalDeviceAntiLagFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 antiLag;
+
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD(const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD& operator=(const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD();
+    ~safe_VkPhysicalDeviceAntiLagFeaturesAMD();
+    void initialize(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAntiLagFeaturesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAntiLagFeaturesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceAntiLagFeaturesAMD*>(this); }
+    VkPhysicalDeviceAntiLagFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAntiLagFeaturesAMD const*>(this);
+    }
+};
+struct safe_VkAntiLagPresentationInfoAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkAntiLagStageAMD stage;
+    uint64_t frameIndex;
+
+    safe_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkAntiLagPresentationInfoAMD(const safe_VkAntiLagPresentationInfoAMD& copy_src);
+    safe_VkAntiLagPresentationInfoAMD& operator=(const safe_VkAntiLagPresentationInfoAMD& copy_src);
+    safe_VkAntiLagPresentationInfoAMD();
+    ~safe_VkAntiLagPresentationInfoAMD();
+    void initialize(const VkAntiLagPresentationInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAntiLagPresentationInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAntiLagPresentationInfoAMD* ptr() { return reinterpret_cast<VkAntiLagPresentationInfoAMD*>(this); }
+    VkAntiLagPresentationInfoAMD const* ptr() const { return reinterpret_cast<VkAntiLagPresentationInfoAMD const*>(this); }
+};
+struct safe_VkAntiLagDataAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAntiLagModeAMD mode;
+    uint32_t maxFPS;
+    safe_VkAntiLagPresentationInfoAMD* pPresentationInfo{};
+
+    safe_VkAntiLagDataAMD(const VkAntiLagDataAMD* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAntiLagDataAMD(const safe_VkAntiLagDataAMD& copy_src);
+    safe_VkAntiLagDataAMD& operator=(const safe_VkAntiLagDataAMD& copy_src);
+    safe_VkAntiLagDataAMD();
+    ~safe_VkAntiLagDataAMD();
+    void initialize(const VkAntiLagDataAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAntiLagDataAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAntiLagDataAMD* ptr() { return reinterpret_cast<VkAntiLagDataAMD*>(this); }
+    VkAntiLagDataAMD const* ptr() const { return reinterpret_cast<VkAntiLagDataAMD const*>(this); }
+};
 struct safe_VkPhysicalDeviceShaderObjectFeaturesEXT {
     VkStructureType sType;
     void* pNext{};

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
@@ -896,6 +896,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolv
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 template <> inline VkStructureType GetSType<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+template <> inline VkStructureType GetSType<VkPhysicalDeviceAntiLagFeaturesAMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagPresentationInfoAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagDataAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkShaderCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; }

diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
@@ -1748,6 +1748,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
             return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
+            return "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
+            return "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
@@ -4682,6 +4688,28 @@ static inline const char* string_VkOpticalFlowSessionBindingPointNV(VkOpticalFlo
             return "Unhandled VkOpticalFlowSessionBindingPointNV";
     }
 }
+static inline const char* string_VkAntiLagModeAMD(VkAntiLagModeAMD input_value) {
+    switch (input_value) {
+        case VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD:
+            return "VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD";
+        case VK_ANTI_LAG_MODE_ON_AMD:
+            return "VK_ANTI_LAG_MODE_ON_AMD";
+        case VK_ANTI_LAG_MODE_OFF_AMD:
+            return "VK_ANTI_LAG_MODE_OFF_AMD";
+        default:
+            return "Unhandled VkAntiLagModeAMD";
+    }
+}
+static inline const char* string_VkAntiLagStageAMD(VkAntiLagStageAMD input_value) {
+    switch (input_value) {
+        case VK_ANTI_LAG_STAGE_INPUT_AMD:
+            return "VK_ANTI_LAG_STAGE_INPUT_AMD";
+        case VK_ANTI_LAG_STAGE_PRESENT_AMD:
+            return "VK_ANTI_LAG_STAGE_PRESENT_AMD";
+        default:
+            return "Unhandled VkAntiLagStageAMD";
+    }
+}
 static inline const char* string_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT input_value) {
     switch (input_value) {
         case VK_SHADER_CODE_TYPE_BINARY_EXT:

diff --git a/scripts/known_good.json b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.290"
+            "commit": "v1.3.291"
         },
         {
             "name": "googletest",

diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1679,6 +1679,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(pNext), copy_state, false);
                 break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceAntiLagFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -3511,6 +3514,9 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+            delete reinterpret_cast<safe_VkPhysicalDeviceAntiLagFeaturesAMD *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
             break;

diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -12735,6 +12735,166 @@ void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize(
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD(
+    const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), antiLag(in_struct->antiLag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD), pNext(nullptr), antiLag() {}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD(
+    const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    antiLag = copy_src.antiLag;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD& safe_VkPhysicalDeviceAntiLagFeaturesAMD::operator=(
+    const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    antiLag = copy_src.antiLag;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::~safe_VkPhysicalDeviceAntiLagFeaturesAMD() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceAntiLagFeaturesAMD::initialize(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    antiLag = in_struct->antiLag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAntiLagFeaturesAMD::initialize(const safe_VkPhysicalDeviceAntiLagFeaturesAMD* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    antiLag = copy_src->antiLag;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stage(in_struct->stage), frameIndex(in_struct->frameIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD), pNext(nullptr), stage(), frameIndex() {}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD(const safe_VkAntiLagPresentationInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    frameIndex = copy_src.frameIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAntiLagPresentationInfoAMD& safe_VkAntiLagPresentationInfoAMD::operator=(const safe_VkAntiLagPresentationInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    frameIndex = copy_src.frameIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAntiLagPresentationInfoAMD::~safe_VkAntiLagPresentationInfoAMD() { FreePnextChain(pNext); }
+
+void safe_VkAntiLagPresentationInfoAMD::initialize(const VkAntiLagPresentationInfoAMD* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stage = in_struct->stage;
+    frameIndex = in_struct->frameIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAntiLagPresentationInfoAMD::initialize(const safe_VkAntiLagPresentationInfoAMD* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    frameIndex = copy_src->frameIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD(const VkAntiLagDataAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType), mode(in_struct->mode), maxFPS(in_struct->maxFPS), pPresentationInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(in_struct->pPresentationInfo);
+}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD()
+    : sType(VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD), pNext(nullptr), mode(), maxFPS(), pPresentationInfo(nullptr) {}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD(const safe_VkAntiLagDataAMD& copy_src) {
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    maxFPS = copy_src.maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src.pPresentationInfo);
+}
+
+safe_VkAntiLagDataAMD& safe_VkAntiLagDataAMD::operator=(const safe_VkAntiLagDataAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    maxFPS = copy_src.maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src.pPresentationInfo);
+
+    return *this;
+}
+
+safe_VkAntiLagDataAMD::~safe_VkAntiLagDataAMD() {
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAntiLagDataAMD::initialize(const VkAntiLagDataAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mode = in_struct->mode;
+    maxFPS = in_struct->maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(in_struct->pPresentationInfo);
+}
+
+void safe_VkAntiLagDataAMD::initialize(const safe_VkAntiLagDataAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mode = copy_src->mode;
+    maxFPS = copy_src->maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src->pPresentationInfo);
+}
+
 safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
     const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), tileProperties(in_struct->tileProperties) {