From 0c1adb9f0a0546997bb1c3021315ada2d14f67e1 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:16:03 -0500 Subject: [PATCH 01/13] build: Remove unused includes --- include/vulkan/layer/vk_layer_settings.hpp | 1 - include/vulkan/utility/vk_safe_struct_utils.hpp | 8 ++++---- src/layer/vk_layer_settings.cpp | 2 -- tests/test_formats.cpp | 1 - 4 files changed, 4 insertions(+), 8 deletions(-) diff --git a/include/vulkan/layer/vk_layer_settings.hpp b/include/vulkan/layer/vk_layer_settings.hpp index 8bcbaeb5..f9c94a90 100644 --- a/include/vulkan/layer/vk_layer_settings.hpp +++ b/include/vulkan/layer/vk_layer_settings.hpp @@ -12,7 +12,6 @@ #include "vk_layer_settings.h" #include -#include #include VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue); diff --git a/include/vulkan/utility/vk_safe_struct_utils.hpp b/include/vulkan/utility/vk_safe_struct_utils.hpp index ff878590..4103def5 100644 --- a/include/vulkan/utility/vk_safe_struct_utils.hpp +++ b/include/vulkan/utility/vk_safe_struct_utils.hpp @@ -15,7 +15,6 @@ #include #include #include -#include namespace vku { @@ -77,14 +76,15 @@ uint32_t FindExtension(CreateInfo& ci, const char* extension_name) { template bool AddExtension(CreateInfo& ci, const char* extension_name) { assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. - uint32_t pos = FindExtension(ci, extension_name); + const uint32_t pos = FindExtension(ci, extension_name); if (pos < ci.enabledExtensionCount) { // already present return false; } char** exts = new char*[ci.enabledExtensionCount + 1]; if (ci.ppEnabledExtensionNames) { - memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount); + memcpy(static_cast(exts), static_cast(ci.ppEnabledExtensionNames), + sizeof(char*) * ci.enabledExtensionCount); } exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name); delete[] ci.ppEnabledExtensionNames; @@ -96,7 +96,7 @@ bool AddExtension(CreateInfo& ci, const char* extension_name) { template bool RemoveExtension(CreateInfo& ci, const char* extension_name) { assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. - uint32_t pos = FindExtension(ci, extension_name); + const uint32_t pos = FindExtension(ci, extension_name); if (pos >= ci.enabledExtensionCount) { // not present return false; diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp index 4d3e1983..41728fe5 100644 --- a/src/layer/vk_layer_settings.cpp +++ b/src/layer/vk_layer_settings.cpp @@ -18,9 +18,7 @@ #include #include #include -#include #include -#include // This is used only for unit tests in test_layer_setting_file void test_helper_SetLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue) { diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp index 58a8498c..10199f78 100644 --- a/tests/test_formats.cpp +++ b/tests/test_formats.cpp @@ -9,7 +9,6 @@ #define MAGIC_ENUM_RANGE_MIN 0 #define MAGIC_ENUM_RANGE_MAX 512 #include -#include #include #include From 5aa664c85642e40aac8dc49e9bb70ce28c53d139 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:25:53 -0500 Subject: [PATCH 02/13] utility: Unify parameter names across files Header and Source file used different parameter names, unified them to share a name for readability. --- include/vulkan/layer/vk_layer_settings.h | 2 +- src/layer/layer_settings_util.cpp | 32 +++++++++++------------- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/include/vulkan/layer/vk_layer_settings.h b/include/vulkan/layer/vk_layer_settings.h index 2709917d..b8aead96 100644 --- a/include/vulkan/layer/vk_layer_settings.h +++ b/include/vulkan/layer/vk_layer_settings.h @@ -71,7 +71,7 @@ const VkLayerSettingsCreateInfoEXT *vkuNextLayerSettingsCreateInfo(const VkLayer // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, - const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t *pUnknownSettingCount, + const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t *pUnknownSettingCount, const char **pUnknownSettings); #ifdef __cplusplus diff --git a/src/layer/layer_settings_util.cpp b/src/layer/layer_settings_util.cpp index 56e813e8..ede8b0b7 100644 --- a/src/layer/layer_settings_util.cpp +++ b/src/layer/layer_settings_util.cpp @@ -19,17 +19,15 @@ namespace vl { std::vector Split(const std::string &pValues, char delimiter) { std::vector result; - std::string parse = pValues; - std::size_t start = 0; - std::size_t end = parse.find(delimiter); + std::size_t end = pValues.find(delimiter); while (end != std::string::npos) { - result.push_back(parse.substr(start, end - start)); + result.push_back(pValues.substr(start, end - start)); start = end + 1; - end = parse.find(delimiter, start); + end = pValues.find(delimiter, start); } - const std::string last = parse.substr(start, end); + const std::string last = pValues.substr(start, end); if (!last.empty()) { result.push_back(last); } @@ -37,12 +35,12 @@ std::vector Split(const std::string &pValues, char delimiter) { return result; } -std::string GetFileSettingName(const char *pLayerName, const char *pSettingName) { - assert(pLayerName != nullptr); - assert(pSettingName != nullptr); +std::string GetFileSettingName(const char *layer_key, const char *setting_key) { + assert(layer_key != nullptr); + assert(setting_key != nullptr); std::stringstream settingName; - settingName << vl::ToLower(TrimPrefix(pLayerName)) << "." << pSettingName; + settingName << vl::ToLower(TrimPrefix(layer_key)) << "." << setting_key; return settingName.str(); } @@ -128,21 +126,21 @@ std::string TrimWhitespace(const std::string &s) { return s.substr(trimmed_beg, trimmed_end - trimmed_beg + 1); } -std::string TrimPrefix(const std::string &layer_key) { +std::string TrimPrefix(const std::string &layer_name) { std::string key{}; - if (layer_key.find("VK_LAYER_") == 0) { - std::size_t prefix = std::strlen("VK_LAYER_"); - key = layer_key.substr(prefix, layer_key.size() - prefix); + if (layer_name.find("VK_LAYER_") == 0) { + const std::size_t prefix = std::strlen("VK_LAYER_"); + key = layer_name.substr(prefix, layer_name.size() - prefix); } else { - key = layer_key; + key = layer_name; } return key; } -std::string TrimVendor(const std::string &layer_key) { +std::string TrimVendor(const std::string &layer_name) { static const char *separator = "_"; - const std::string &namespace_key = TrimPrefix(layer_key); + const std::string &namespace_key = TrimPrefix(layer_name); const auto trimmed_beg = namespace_key.find_first_of(separator); if (trimmed_beg == std::string::npos) return namespace_key; From 53ff35658289c331d34ffe2b87c55157ff69859c Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:28:41 -0500 Subject: [PATCH 03/13] style: Remove redundant parenthesis --- include/vulkan/utility/vk_format_utils.h | 2 +- .../vulkan/utility/vk_sparse_range_map.hpp | 6 ++--- scripts/generators/format_utils_generator.py | 2 +- src/vulkan/vk_safe_struct_manual.cpp | 22 +++++++++---------- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h index 570f01b9..8a287c4c 100644 --- a/include/vulkan/utility/vk_format_utils.h +++ b/include/vulkan/utility/vk_format_utils.h @@ -269,7 +269,7 @@ static inline uint32_t vkuFormatPlaneCount(VkFormat format); // Returns whether a VkFormat is multiplane // Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a // VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead -static inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); } +static inline bool vkuFormatIsMultiplane(VkFormat format) { return (vkuFormatPlaneCount(format) > 1u); } // Returns a VkFormat that is compatible with a given plane of a multiplane format // Will return VK_FORMAT_UNDEFINED if given a plane aspect that doesn't exist for the format diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp index 36b8460c..4f05eec6 100644 --- a/include/vulkan/utility/vk_sparse_range_map.hpp +++ b/include/vulkan/utility/vk_sparse_range_map.hpp @@ -765,7 +765,7 @@ class small_range_map { using Value = Value_; friend Map; Value *operator->() const { return map_->get_value(pos_); } - Value &operator*() const { return *(map_->get_value(pos_)); } + Value &operator*() const { return *map_->get_value(pos_); } IteratorImpl &operator++() { pos_ = map_->next_range(pos_); return *this; @@ -1302,12 +1302,12 @@ class small_range_map { } value_type *get_value(SmallIndex index) { assert(index < limit_); // Must be inbounds - return reinterpret_cast(&(backing_store_[index])); + return reinterpret_cast(&backing_store_[index]); } const value_type *get_value(SmallIndex index) const { assert(index < limit_); // Must be inbounds assert(index == ranges_[index].begin); // Must be the record at begin - return reinterpret_cast(&(backing_store_[index])); + return reinterpret_cast(&backing_store_[index]); } template diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py index 1b69f8bf..7dca6203 100644 --- a/scripts/generators/format_utils_generator.py +++ b/scripts/generators/format_utils_generator.py @@ -204,7 +204,7 @@ def generate(self): // Returns whether a VkFormat is multiplane // Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a // VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead -static inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); } +static inline bool vkuFormatIsMultiplane(VkFormat format) { return (vkuFormatPlaneCount(format) > 1u); } // Returns a VkFormat that is compatible with a given plane of a multiplane format // Will return VK_FORMAT_UNDEFINED if given a plane aspect that doesn't exist for the format diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp index 4faa289c..c0fc79b9 100644 --- a/src/vulkan/vk_safe_struct_manual.cpp +++ b/src/vulkan/vk_safe_struct_manual.cpp @@ -71,8 +71,8 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR allocation + build_range_info->primitiveOffset + pp_array_size); for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) { const uint8_t* byte_ptr = reinterpret_cast(in_struct->geometry.instances.data.hostAddress); - pInstances[i] = *( - reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]); + pInstances[i] = + *reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]; ppInstances[i] = &pInstances[i]; } geometry.instances.data.hostAddress = allocation; @@ -125,7 +125,7 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { pInstances[i] = - *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + *reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]; ppInstances[i] = &pInstances[i]; } geometry.instances.data.hostAddress = allocation; @@ -186,7 +186,7 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { pInstances[i] = - *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + *reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]; ppInstances[i] = &pInstances[i]; } geometry.instances.data.hostAddress = allocation; @@ -261,8 +261,8 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr allocation + build_range_info->primitiveOffset + pp_array_size); for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) { const uint8_t* byte_ptr = reinterpret_cast(in_struct->geometry.instances.data.hostAddress); - pInstances[i] = *( - reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]); + pInstances[i] = + *reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]; ppInstances[i] = &pInstances[i]; } geometry.instances.data.hostAddress = allocation; @@ -328,7 +328,7 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { pInstances[i] = - *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + *reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]; ppInstances[i] = &pInstances[i]; } geometry.instances.data.hostAddress = allocation; @@ -1058,8 +1058,8 @@ safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBu } else { pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; for (uint32_t i = 0; i < geometryCount; ++i) { - (pGeometries)[i] = - safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]); + pGeometries[i] = + safe_VkAccelerationStructureGeometryKHR(&in_struct->pGeometries[i], is_host, &build_range_infos[i]); } } } @@ -1196,8 +1196,8 @@ void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const VkAccele } else { pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; for (uint32_t i = 0; i < geometryCount; ++i) { - (pGeometries)[i] = - safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]); + pGeometries[i] = + safe_VkAccelerationStructureGeometryKHR(&in_struct->pGeometries[i], is_host, &build_range_infos[i]); } } } From 32ab578598634cfcffc5e6c21df8d7d41984b5b4 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:31:53 -0500 Subject: [PATCH 04/13] style: Remove redundant casts --- src/layer/layer_settings_manager.cpp | 2 +- src/layer/vk_layer_settings_helper.cpp | 3 ++- tests/test_setting_api.cpp | 18 +++++++++--------- tests/test_setting_env.cpp | 18 +++++++++--------- tests/test_setting_file.cpp | 18 +++++++++--------- 5 files changed, 30 insertions(+), 29 deletions(-) diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp index 38179f2c..2a4a0e3c 100644 --- a/src/layer/layer_settings_manager.cpp +++ b/src/layer/layer_settings_manager.cpp @@ -364,7 +364,7 @@ void LayerSettings::SetFileSetting(const char *pSettingName, const std::string & const VkLayerSettingEXT *LayerSettings::GetAPISetting(const char *pSettingName) { assert(pSettingName != nullptr); - return reinterpret_cast(this->FindLayerSettingValue(pSettingName)); + return this->FindLayerSettingValue(pSettingName); } } // namespace vl diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp index 679ff291..51d78b58 100644 --- a/src/layer/vk_layer_settings_helper.cpp +++ b/src/layer/vk_layer_settings_helper.cpp @@ -193,7 +193,8 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char if (value_count > 0) { std::vector values(value_count); - result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&values[0])); settingValues.assign(values.begin(), values.end()); } return result; diff --git a/tests/test_setting_api.cpp b/tests/test_setting_api.cpp index 1515ddbf..8afbdad1 100644 --- a/tests/test_setting_api.cpp +++ b/tests/test_setting_api.cpp @@ -205,7 +205,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Bool) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1u; VkResult result_incomplete = @@ -246,7 +246,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -287,7 +287,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -328,7 +328,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -369,7 +369,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -410,7 +410,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -450,7 +450,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -492,7 +492,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -537,7 +537,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = diff --git a/tests/test_setting_env.cpp b/tests/test_setting_env.cpp index dc949470..d28e42a4 100644 --- a/tests/test_setting_env.cpp +++ b/tests/test_setting_env.cpp @@ -165,7 +165,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -200,7 +200,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -235,7 +235,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -270,7 +270,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -305,7 +305,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -340,7 +340,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -374,7 +374,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -408,7 +408,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -448,7 +448,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = diff --git a/tests/test_setting_file.cpp b/tests/test_setting_file.cpp index 4aeb6f31..d6c14a6b 100644 --- a/tests/test_setting_file.cpp +++ b/tests/test_setting_file.cpp @@ -27,7 +27,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -62,7 +62,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -97,7 +97,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -132,7 +132,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -167,7 +167,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -202,7 +202,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -236,7 +236,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -270,7 +270,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = @@ -310,7 +310,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) { EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(2u, value_count); - std::vector values(static_cast(value_count)); + std::vector values(value_count); value_count = 1; VkResult result_incomplete = From d7d627e5f0490f8a93dfcc049c6ebfff140e6362 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:37:15 -0500 Subject: [PATCH 05/13] tests: Add necessary casts for correctness The API takes things by single pointer but many tests are passing a double pointer. Make it explicit by using the appropriate cast. --- tests/test_setting_api.cpp | 11 ++++++----- tests/test_setting_cast.cpp | 36 ++++++++++++++++++------------------ tests/test_setting_cpp.cpp | 11 ++++++----- tests/test_setting_env.cpp | 8 ++++---- tests/test_setting_file.cpp | 8 ++++---- 5 files changed, 38 insertions(+), 36 deletions(-) diff --git a/tests/test_setting_api.cpp b/tests/test_setting_api.cpp index 8afbdad1..e321aa28 100644 --- a/tests/test_setting_api.cpp +++ b/tests/test_setting_api.cpp @@ -521,7 +521,8 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) { TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) { std::vector input_values{"VALUE_A", "VALUE_B"}; std::vector settings{{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, - static_cast(input_values.size()), &input_values[0]}}; + static_cast(input_values.size()), + static_cast(&input_values[0])}}; VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast(settings.size()), &settings[0]}; @@ -540,16 +541,16 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) { std::vector values(value_count); value_count = 1; - VkResult result_incomplete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_incomplete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, + &value_count, static_cast(&values[0])); EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ(nullptr, values[1]); EXPECT_EQ(1u, value_count); value_count = 2; - VkResult result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_B", values[1]); diff --git a/tests/test_setting_cast.cpp b/tests/test_setting_cast.cpp index c7f1c4ff..ddcad399 100644 --- a/tests/test_setting_cast.cpp +++ b/tests/test_setting_cast.cpp @@ -38,8 +38,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("true", string_values[0]); @@ -74,8 +74,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int32) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("76", string_values[0]); @@ -110,8 +110,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int64) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("76", string_values[0]); @@ -146,8 +146,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint32) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("76", string_values[0]); @@ -182,8 +182,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("76", string_values[0]); @@ -218,8 +218,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); @@ -254,8 +254,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Double) { std::vector string_values(input_values.size()); - result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]); + result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr); @@ -303,7 +303,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) { value_count = 2; result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, - &string_values[0]); + static_cast(&string_values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); EXPECT_STREQ("76-100-10", string_values[0]); @@ -315,7 +315,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) { TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) { std::vector input_values{"VALUE_A", "VALUE_B"}; std::vector settings{{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, - static_cast(input_values.size()), &input_values[0]}}; + static_cast(input_values.size()), static_cast(&input_values[0])}}; VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast(settings.size()), &settings[0]}; @@ -328,8 +328,8 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) { std::vector values(input_values.size()); uint32_t value_count = 2; - VkResult result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_B", values[1]); diff --git a/tests/test_setting_cpp.cpp b/tests/test_setting_cpp.cpp index 081f71a0..c80a3f19 100644 --- a/tests/test_setting_cpp.cpp +++ b/tests/test_setting_cpp.cpp @@ -368,7 +368,8 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Double) { TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_String) { const char* value_data[] = {"VALUE_A"}; - const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, value_data}; + const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, + reinterpret_cast(value_data)}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting}; @@ -387,8 +388,8 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Strings) { const char* values_data[] = {"VALUE_A", "VALUE_B"}; const uint32_t value_count = static_cast(std::size(values_data)); - const VkLayerSettingEXT settings[] = { - {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}}; + const VkLayerSettingEXT settings[] = {{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, + reinterpret_cast(values_data)}}; const uint32_t settings_size = static_cast(std::size(settings)); const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, @@ -408,8 +409,8 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_String) { const char* values_data[] = {"VALUE_A", "VALUE_B"}; const uint32_t value_count = static_cast(std::size(values_data)); - const VkLayerSettingEXT settings[] = { - {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}}; + const VkLayerSettingEXT settings[] = {{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, + reinterpret_cast(values_data)}}; const uint32_t settings_size = static_cast(std::size(settings)); const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, diff --git a/tests/test_setting_env.cpp b/tests/test_setting_env.cpp index d28e42a4..c8f0c391 100644 --- a/tests/test_setting_env.cpp +++ b/tests/test_setting_env.cpp @@ -451,16 +451,16 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) { std::vector values(value_count); value_count = 1; - VkResult result_incomplete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_incomplete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, + &value_count, static_cast(&values[0])); EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ(nullptr, values[1]); EXPECT_EQ(1u, value_count); value_count = 2; - VkResult result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_B", values[1]); diff --git a/tests/test_setting_file.cpp b/tests/test_setting_file.cpp index d6c14a6b..6bf69074 100644 --- a/tests/test_setting_file.cpp +++ b/tests/test_setting_file.cpp @@ -313,16 +313,16 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) { std::vector values(value_count); value_count = 1; - VkResult result_incomplete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_incomplete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, + &value_count, static_cast(&values[0])); EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ(nullptr, values[1]); EXPECT_EQ(1u, value_count); value_count = 2; - VkResult result_complete = - vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]); + VkResult result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, + static_cast(&values[0])); EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_STREQ("VALUE_A", values[0]); EXPECT_STREQ("VALUE_B", values[1]); From c2af6c3da5d6b413a2b53ed0046474dee9e1469b Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:39:43 -0500 Subject: [PATCH 06/13] Style: Move assignment out of conditional Bad style to have an assignment occurring inside of a conditional. --- src/layer/layer_settings_manager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp index 2a4a0e3c..29bccd26 100644 --- a/src/layer/layer_settings_manager.cpp +++ b/src/layer/layer_settings_manager.cpp @@ -347,8 +347,8 @@ std::string LayerSettings::GetEnvSetting(const char *pSettingName) { std::string LayerSettings::GetFileSetting(const char *pSettingName) { const std::string file_setting_name = vl::GetFileSettingName(this->layer_name.c_str(), pSettingName); - std::map::const_iterator it; - if ((it = this->setting_file_values.find(file_setting_name)) == this->setting_file_values.end()) { + const std::map::const_iterator it = this->setting_file_values.find(file_setting_name); + if (it == this->setting_file_values.end()) { return ""; } else { return it->second; From 324433abe46df531ede968ab82b1d894301eba52 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:42:58 -0500 Subject: [PATCH 07/13] utility: Make copy operators not copy over themselves --- include/vulkan/utility/vk_sparse_range_map.hpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp index 4f05eec6..be11d20f 100644 --- a/include/vulkan/utility/vk_sparse_range_map.hpp +++ b/include/vulkan/utility/vk_sparse_range_map.hpp @@ -86,6 +86,7 @@ struct range { bool strictly_greater(const index_type &index) const { return index < begin; } range &operator=(const range &rhs) { + if (this == &rhs) return *this; begin = rhs.begin; end = rhs.end; return *this; @@ -462,6 +463,7 @@ class range_map { iterator_impl(const iterator_impl &other) : pos_(other.pos_) {} iterator_impl &operator=(const iterator_impl &rhs) { + if (this == &rhs) return *this; pos_ = rhs.pos_; return *this; } @@ -498,6 +500,7 @@ class range_map { public: const_iterator &operator=(const const_iterator &other) { + if (&other == this) return *this; Base::operator=(other); return *this; } @@ -775,6 +778,7 @@ class small_range_map { return *this; } IteratorImpl &operator=(const IteratorImpl &other) { + if (&other == this) return *this; map_ = other.map_; pos_ = other.pos_; return *this; From 4df17def33927a7abff7c694040c73753480b94e Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:54:14 -0500 Subject: [PATCH 08/13] style: Add const where it makes sense --- .../utility/vk_concurrent_unordered_map.hpp | 20 ++++----- .../vulkan/utility/vk_small_containers.hpp | 2 +- .../vulkan/utility/vk_sparse_range_map.hpp | 12 +++--- src/layer/layer_settings_manager.cpp | 4 +- src/layer/vk_layer_settings.cpp | 6 +-- src/layer/vk_layer_settings_helper.cpp | 4 +- src/vulkan/vk_safe_struct_manual.cpp | 43 ++++++++++--------- 7 files changed, 47 insertions(+), 44 deletions(-) diff --git a/include/vulkan/utility/vk_concurrent_unordered_map.hpp b/include/vulkan/utility/vk_concurrent_unordered_map.hpp index a6e9b1ca..4a0a52dd 100644 --- a/include/vulkan/utility/vk_concurrent_unordered_map.hpp +++ b/include/vulkan/utility/vk_concurrent_unordered_map.hpp @@ -67,9 +67,9 @@ class unordered_map { template bool insert(const Key &key, Args &&...args) { - uint32_t h = ConcurrentMapHashObject(key); - WriteLockGuard lock(locks[h].lock); - auto ret = maps[h].emplace(key, std::forward(args)...); + const uint32_t h = ConcurrentMapHashObject(key); + const WriteLockGuard lock(locks[h].lock); + const auto ret = maps[h].emplace(key, std::forward(args)...); return ret.second; } @@ -115,10 +115,10 @@ class unordered_map { FindResult cend() const { return end(); } FindResult find(const Key &key) const { - uint32_t h = ConcurrentMapHashObject(key); - ReadLockGuard lock(locks[h].lock); + const uint32_t h = ConcurrentMapHashObject(key); + const ReadLockGuard lock(locks[h].lock); - auto itr = maps[h].find(key); + const auto itr = maps[h].find(key); const bool found = itr != maps[h].end(); if (found) { @@ -129,10 +129,10 @@ class unordered_map { } FindResult pop(const Key &key) { - uint32_t h = ConcurrentMapHashObject(key); - WriteLockGuard lock(locks[h].lock); + const uint32_t h = ConcurrentMapHashObject(key); + const WriteLockGuard lock(locks[h].lock); - auto itr = maps[h].find(key); + const auto itr = maps[h].find(key); const bool found = itr != maps[h].end(); if (found) { @@ -192,7 +192,7 @@ class unordered_map { mutable std::array locks; uint32_t ConcurrentMapHashObject(const Key &object) const { - uint64_t u64 = (uint64_t)(uintptr_t)object; + const uint64_t u64 = (uint64_t)(uintptr_t)object; uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64; hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2)); hash &= (BUCKETS - 1); diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp index 71cae2fc..afbeb79a 100644 --- a/include/vulkan/utility/vk_small_containers.hpp +++ b/include/vulkan/utility/vk_small_containers.hpp @@ -271,7 +271,7 @@ class vector { } else if ((capacity_ > kSmallCapacity) && (capacity_ > size_)) { auto source = GetWorkingStore(); // Keep the source from disappearing until the end of the function - auto old_store = std::unique_ptr(std::move(large_store_)); + const auto old_store = std::unique_ptr(std::move(large_store_)); assert(!large_store_); if (size_ < kSmallCapacity) { capacity_ = kSmallCapacity; diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp index be11d20f..5e96606f 100644 --- a/include/vulkan/utility/vk_sparse_range_map.hpp +++ b/include/vulkan/utility/vk_sparse_range_map.hpp @@ -590,7 +590,7 @@ class range_map { const_iterator find(const key_type &key) const { return const_iterator(impl_map_.find(key)); } iterator find(const index_type &index) { - auto lower = lower_bound(range(index, index + 1)); + const auto lower = lower_bound(range(index, index + 1)); if (!at_end(lower) && lower->first.includes(index)) { return lower; } @@ -629,12 +629,12 @@ class range_map { // Look for range conflicts (and an insertion point, which makes the lower_bound *not* wasted work) // we don't have to check upper if just check that lower doesn't intersect (which it would if lower != upper) - auto lower = lower_bound_impl(key); + const auto lower = lower_bound_impl(key); if (at_impl_end(lower) || !lower->first.intersects(key)) { // range is not even partially overlapped, and lower is strictly > than key - auto impl_insert = impl_map_.emplace_hint(lower, value); + const auto impl_insert = impl_map_.emplace_hint(lower, value); // auto impl_insert = impl_map_.emplace(value); - iterator wrap_it(impl_insert); + const iterator wrap_it(impl_insert); return std::make_pair(wrap_it, true); } // We don't replace @@ -2027,8 +2027,8 @@ void consolidate(RangeMap &map) { // Returns the intersection of the ranges [x, x + x_size) and [y, y + y_size) static inline range GetRangeIntersection(int64_t x, uint64_t x_size, int64_t y, uint64_t y_size) { - int64_t intersection_min = std::max(x, y); - int64_t intersection_max = std::min(x + static_cast(x_size), y + static_cast(y_size)); + const int64_t intersection_min = std::max(x, y); + const int64_t intersection_max = std::min(x + static_cast(x_size), y + static_cast(y_size)); return {intersection_min, intersection_max}; } diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp index 29bccd26..69b9bd69 100644 --- a/src/layer/layer_settings_manager.cpp +++ b/src/layer/layer_settings_manager.cpp @@ -133,7 +133,7 @@ LayerSettings::LayerSettings(const char *pLayerName, const VkLayerSettingsCreate (void)pAllocator; assert(pLayerName != nullptr); - std::filesystem::path settings_file = this->FindSettingsFile(); + const std::filesystem::path settings_file = this->FindSettingsFile(); this->ParseSettingsFile(settings_file); } @@ -304,7 +304,7 @@ bool LayerSettings::HasEnvSetting(const char *pSettingName) { bool LayerSettings::HasFileSetting(const char *pSettingName) { assert(pSettingName != nullptr); - std::string file_setting_name = vl::GetFileSettingName(this->layer_name.c_str(), pSettingName); + const std::string file_setting_name = vl::GetFileSettingName(this->layer_name.c_str(), pSettingName); return setting_file_values.find(file_setting_name) != setting_file_values.end(); } diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp index 41728fe5..92fc8232 100644 --- a/src/layer/vk_layer_settings.cpp +++ b/src/layer/vk_layer_settings.cpp @@ -45,7 +45,7 @@ VkResult vkuCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsC void vkuDestroyLayerSettingSet(VkuLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) { (void)pAllocator; - vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet; + const vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet; delete layer_setting_set; } @@ -678,7 +678,7 @@ const VkLayerSettingsCreateInfoEXT *vkuNextLayerSettingsCreateInfo(const VkLayer return found; } -static bool vkuHasSetting(uint32_t settingsCount, const char **pSettings, const char *searchedSettings) { +static bool vkuHasSetting(uint32_t settingsCount, const char *const *pSettings, const char *searchedSettings) { for (uint32_t setting_index = 0; setting_index < settingsCount; ++setting_index) { if (std::strcmp(pSettings[setting_index], searchedSettings) == 0) { return true; @@ -697,7 +697,7 @@ VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t laye return VK_ERROR_INITIALIZATION_FAILED; } - vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet; + const vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet; const VkLayerSettingsCreateInfoEXT *current_create_info = pCreateInfo; diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp index 51d78b58..162ae0a5 100644 --- a/src/layer/vk_layer_settings_helper.cpp +++ b/src/layer/vk_layer_settings_helper.cpp @@ -26,7 +26,7 @@ static std::string Merge(const std::vector &strings) { VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) { uint32_t value_count = 1; VkBool32 pValues = settingValue ? VK_TRUE : VK_FALSE; - VkResult result = + const VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues); settingValue = pValues == VK_TRUE; return result; @@ -178,7 +178,7 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) { std::vector values; - VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, values); + const VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, values); settingValue = Merge(values); return result; } diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp index c0fc79b9..794a960a 100644 --- a/src/vulkan/vk_safe_struct_manual.cpp +++ b/src/vulkan/vk_safe_struct_manual.cpp @@ -61,9 +61,9 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR } if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) { if (geometry.instances.arrayOfPointers) { - size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); - size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); - size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; + const size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + const size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; uint8_t* allocation = new uint8_t[array_size]; VkAccelerationStructureInstanceKHR** ppInstances = reinterpret_cast(allocation + build_range_info->primitiveOffset); @@ -81,7 +81,7 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR } else { const auto primitive_offset = build_range_info->primitiveOffset; const auto primitive_count = build_range_info->primitiveCount; - size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); uint8_t* allocation = new uint8_t[array_size]; auto host_address = static_cast(in_struct->geometry.instances.data.hostAddress); memcpy(allocation + primitive_offset, host_address + primitive_offset, @@ -115,9 +115,9 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR if (src_iter != GetAccelStructGeomHostAllocMap().end()) { auto& src_alloc = src_iter->second; if (geometry.instances.arrayOfPointers) { - size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); - size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); - size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + const size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + const size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; uint8_t* allocation = new uint8_t[array_size]; VkAccelerationStructureInstanceKHR** ppInstances = reinterpret_cast(allocation + src_alloc->primitiveOffset); @@ -132,7 +132,8 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR GetAccelStructGeomHostAllocMap().insert( this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); } else { - size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = + src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); uint8_t* allocation = new uint8_t[array_size]; memcpy(allocation, src_alloc->ptr, array_size); geometry.instances.data.hostAddress = allocation; @@ -176,9 +177,9 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR if (src_iter != GetAccelStructGeomHostAllocMap().end()) { auto& src_alloc = src_iter->second; if (geometry.instances.arrayOfPointers) { - size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); - size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); - size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + const size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + const size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; uint8_t* allocation = new uint8_t[array_size]; VkAccelerationStructureInstanceKHR** ppInstances = reinterpret_cast(allocation + src_alloc->primitiveOffset); @@ -193,7 +194,8 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR GetAccelStructGeomHostAllocMap().insert( this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); } else { - size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = + src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); uint8_t* allocation = new uint8_t[array_size]; memcpy(allocation, src_alloc->ptr, array_size); geometry.instances.data.hostAddress = allocation; @@ -251,9 +253,9 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) { if (geometry.instances.arrayOfPointers) { - size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); - size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); - size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; + const size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + const size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; uint8_t* allocation = new uint8_t[array_size]; VkAccelerationStructureInstanceKHR** ppInstances = reinterpret_cast(allocation + build_range_info->primitiveOffset); @@ -271,7 +273,7 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr } else { const auto primitive_offset = build_range_info->primitiveOffset; const auto primitive_count = build_range_info->primitiveCount; - size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); uint8_t* allocation = new uint8_t[array_size]; auto host_address = static_cast(in_struct->geometry.instances.data.hostAddress); memcpy(allocation + primitive_offset, host_address + primitive_offset, @@ -318,9 +320,9 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati if (src_iter != GetAccelStructGeomHostAllocMap().end()) { auto& src_alloc = src_iter->second; if (geometry.instances.arrayOfPointers) { - size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); - size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); - size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + const size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + const size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; uint8_t* allocation = new uint8_t[array_size]; VkAccelerationStructureInstanceKHR** ppInstances = reinterpret_cast(allocation + src_alloc->primitiveOffset); @@ -335,7 +337,8 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati GetAccelStructGeomHostAllocMap().insert( this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); } else { - size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + const size_t array_size = + src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); uint8_t* allocation = new uint8_t[array_size]; memcpy(allocation, src_alloc->ptr, array_size); geometry.instances.data.hostAddress = allocation; From 5837ac07008daff02eb48b1ef0c6d963181543ac Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:56:32 -0500 Subject: [PATCH 09/13] utility: Mark single argument constructors explicit This prevents accidental conversions from taking place. --- include/vulkan/utility/vk_small_containers.hpp | 3 ++- include/vulkan/utility/vk_sparse_range_map.hpp | 14 +++++++------- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp index afbeb79a..0eddd635 100644 --- a/include/vulkan/utility/vk_small_containers.hpp +++ b/include/vulkan/utility/vk_small_containers.hpp @@ -55,7 +55,8 @@ class vector { other.clear(); } - vector(size_type size, const value_type &value = value_type()) : size_(0), capacity_(N), working_store_(GetSmallStore()) { + explicit vector(size_type size, const value_type &value = value_type()) noexcept + : size_(0), capacity_(N), working_store_(GetSmallStore()) { reserve(size); auto dest = GetWorkingStore(); for (size_type i = 0; i < size; i++) { diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp index 5e96606f..70f5ddf2 100644 --- a/include/vulkan/utility/vk_sparse_range_map.hpp +++ b/include/vulkan/utility/vk_sparse_range_map.hpp @@ -120,12 +120,12 @@ class range_view { } const index_type &operator*() const { return current; } bool operator!=(const iterator &rhs) const { return current != rhs.current; } - iterator(index_type value) : current(value) {} + explicit iterator(index_type value) : current(value) {} private: index_type current; }; - range_view(const Range &range) : range_(range) {} + explicit range_view(const Range &range) : range_(range) {} const iterator begin() const { return iterator(range_.begin); } const iterator end() const { return iterator(range_.end); } @@ -456,7 +456,7 @@ class range_map { WrappedIterator pos_; // Create an iterator at a specific internal state -- only from the parent container - iterator_impl(const WrappedIterator &pos) : pos_(pos) {} + explicit iterator_impl(const WrappedIterator &pos) : pos_(pos) {} public: iterator_impl() : iterator_impl(WrappedIterator()) {} @@ -505,11 +505,11 @@ class range_map { return *this; } const_iterator(const const_iterator &other) : Base(other) {} - const_iterator(const iterator &it) : Base(ImplConstIterator(it.get_pos())) {} + explicit const_iterator(const iterator &it) : Base(ImplConstIterator(it.get_pos())) {} const_iterator() : Base() {} private: - const_iterator(const ImplConstIterator &pos) : Base(pos) {} + explicit const_iterator(const ImplConstIterator &pos) : Base(pos) {} }; protected: @@ -816,7 +816,7 @@ class small_range_map { friend small_range_map; public: - const_iterator(const iterator &it) : Base(it.get_map(), it.get_pos()) {} + explicit const_iterator(const iterator &it) : Base(it.get_map(), it.get_pos()) {} const_iterator() : Base() {} private: @@ -1104,7 +1104,7 @@ class small_range_map { iterator upper_bound(const key_type &key) { return iterator(this, upper_bound_impl(this, key)); } const_iterator upper_bound(const key_type &key) const { return const_iterator(this, upper_bound_impl(this, key)); } - small_range_map(index_type limit = N) : size_(0), limit_(static_cast(limit)) { + explicit small_range_map(index_type limit = N) : size_(0), limit_(static_cast(limit)) { assert(limit <= std::numeric_limits::max()); init_range(); } From 3ea126e9f3b20d5d020437586ac4b6f99583ed87 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 11:58:01 -0500 Subject: [PATCH 10/13] utility: Mark move operators noexcept Move operators should never throw. --- include/vulkan/utility/vk_small_containers.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp index 0eddd635..108f4ef2 100644 --- a/include/vulkan/utility/vk_small_containers.hpp +++ b/include/vulkan/utility/vk_small_containers.hpp @@ -45,7 +45,7 @@ class vector { vector(const vector &other) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(other); } - vector(vector &&other) : size_(0), capacity_(N), working_store_(GetSmallStore()) { + vector(vector &&other) noexcept : size_(0), capacity_(N), working_store_(GetSmallStore()) { if (other.large_store_) { MoveLargeStore(other); } else { @@ -116,7 +116,7 @@ class vector { return *this; } - vector &operator=(vector &&other) { + vector &operator=(vector &&other) noexcept { if (this != &other) { // Note: move assign doesn't require other to become empty (as does move construction) // so we'll leave other alone except in the large store case, while moving the object From 77db3c442ee75bebf0ae18fc06f31fb7d9336ebc Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 12:02:16 -0500 Subject: [PATCH 11/13] style: Avoid signed bitwise ops Signed bitwise ops can be confusing and is easy to invoke undefined behavior. --- .../utility/vk_concurrent_unordered_map.hpp | 8 +- include/vulkan/vk_enum_string_helper.h | 1044 ++++++++--------- .../enum_string_helper_generator.py | 6 +- tests/test_setting_api.cpp | 2 +- tests/test_setting_cpp.cpp | 2 +- tests/test_setting_util.cpp | 4 +- 6 files changed, 533 insertions(+), 533 deletions(-) diff --git a/include/vulkan/utility/vk_concurrent_unordered_map.hpp b/include/vulkan/utility/vk_concurrent_unordered_map.hpp index 4a0a52dd..782c926e 100644 --- a/include/vulkan/utility/vk_concurrent_unordered_map.hpp +++ b/include/vulkan/utility/vk_concurrent_unordered_map.hpp @@ -49,7 +49,7 @@ constexpr std::size_t get_hardware_destructive_interference_size() { return 64; // // snapshot: Return an array of elements (key, value pairs) that satisfy an optional // predicate. This can be used as a substitute for iterators in exceptional cases. -template > +template > class unordered_map { // Aliases to avoid excessive typing. We can't easily auto these away because // there are virtual methods in ValidationObject which return lock guards @@ -183,7 +183,7 @@ class unordered_map { } private: - static const int BUCKETS = (1 << BUCKETSLOG2); + static const int BUCKETS = (1u << BUCKETSLOG2); Map maps[BUCKETS]; struct alignas(get_hardware_destructive_interference_size()) AlignedSharedMutex { @@ -193,9 +193,9 @@ class unordered_map { uint32_t ConcurrentMapHashObject(const Key &object) const { const uint64_t u64 = (uint64_t)(uintptr_t)object; - uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64; + uint32_t hash = (uint32_t)(u64 >> 32u) + (uint32_t)u64; hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2)); - hash &= (BUCKETS - 1); + hash &= (BUCKETS - 1u); return hash; } }; diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index da940201..8a09ae6d 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -6403,14 +6403,14 @@ static inline const char* string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits #ifdef __cplusplus static inline std::string string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFormatFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFormatFeatureFlags(0)"); return ret; @@ -6468,14 +6468,14 @@ static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits inp #ifdef __cplusplus static inline std::string string_VkImageCreateFlags(VkImageCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageCreateFlags(0)"); return ret; @@ -6505,14 +6505,14 @@ static inline const char* string_VkSampleCountFlagBits(VkSampleCountFlagBits inp #ifdef __cplusplus static inline std::string string_VkSampleCountFlags(VkSampleCountFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSampleCountFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSampleCountFlags(0)"); return ret; @@ -6578,14 +6578,14 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input #ifdef __cplusplus static inline std::string string_VkImageUsageFlags(VkImageUsageFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageUsageFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageUsageFlags(0)"); return ret; @@ -6603,14 +6603,14 @@ static inline const char* string_VkInstanceCreateFlagBits(VkInstanceCreateFlagBi #ifdef __cplusplus static inline std::string string_VkInstanceCreateFlags(VkInstanceCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkInstanceCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkInstanceCreateFlags(0)"); return ret; @@ -6632,14 +6632,14 @@ static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input #ifdef __cplusplus static inline std::string string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryHeapFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryHeapFlags(0)"); return ret; @@ -6673,14 +6673,14 @@ static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBi #ifdef __cplusplus static inline std::string string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryPropertyFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryPropertyFlags(0)"); return ret; @@ -6714,14 +6714,14 @@ static inline const char* string_VkQueueFlagBits(VkQueueFlagBits input_value) { #ifdef __cplusplus static inline std::string string_VkQueueFlags(VkQueueFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkQueueFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkQueueFlags(0)"); return ret; @@ -6775,14 +6775,14 @@ static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_val if (input_value == VK_SHADER_STAGE_ALL_GRAPHICS) { return "VK_SHADER_STAGE_ALL_GRAPHICS"; } if (input_value == VK_SHADER_STAGE_ALL) { return "VK_SHADER_STAGE_ALL"; } std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkShaderStageFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkShaderStageFlags(0)"); return ret; @@ -6802,14 +6802,14 @@ static inline const char* string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreate #ifdef __cplusplus static inline std::string string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDeviceQueueCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDeviceQueueCreateFlags(0)"); return ret; @@ -6879,14 +6879,14 @@ static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits #ifdef __cplusplus static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineStageFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineStageFlags(0)"); return ret; @@ -6904,14 +6904,14 @@ static inline const char* string_VkMemoryMapFlagBits(VkMemoryMapFlagBits input_v #ifdef __cplusplus static inline std::string string_VkMemoryMapFlags(VkMemoryMapFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryMapFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryMapFlags(0)"); return ret; @@ -6951,14 +6951,14 @@ static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits inp #ifdef __cplusplus static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageAspectFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageAspectFlags(0)"); return ret; @@ -6980,14 +6980,14 @@ static inline const char* string_VkSparseImageFormatFlagBits(VkSparseImageFormat #ifdef __cplusplus static inline std::string string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSparseImageFormatFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSparseImageFormatFlags(0)"); return ret; @@ -7005,14 +7005,14 @@ static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFl #ifdef __cplusplus static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSparseMemoryBindFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSparseMemoryBindFlags(0)"); return ret; @@ -7030,14 +7030,14 @@ static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits inp #ifdef __cplusplus static inline std::string string_VkFenceCreateFlags(VkFenceCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFenceCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFenceCreateFlags(0)"); return ret; @@ -7055,14 +7055,14 @@ static inline const char* string_VkQueryPoolCreateFlagBits(VkQueryPoolCreateFlag #ifdef __cplusplus static inline std::string string_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkQueryPoolCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkQueryPoolCreateFlags(0)"); return ret; @@ -7106,14 +7106,14 @@ static inline const char* string_VkQueryPipelineStatisticFlagBits(VkQueryPipelin #ifdef __cplusplus static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkQueryPipelineStatisticFlags(0)"); return ret; @@ -7139,14 +7139,14 @@ static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits inp #ifdef __cplusplus static inline std::string string_VkQueryResultFlags(VkQueryResultFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkQueryResultFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkQueryResultFlags(0)"); return ret; @@ -7176,14 +7176,14 @@ static inline const char* string_VkBufferCreateFlagBits(VkBufferCreateFlagBits i #ifdef __cplusplus static inline std::string string_VkBufferCreateFlags(VkBufferCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkBufferCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkBufferCreateFlags(0)"); return ret; @@ -7257,14 +7257,14 @@ static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits inp #ifdef __cplusplus static inline std::string string_VkBufferUsageFlags(VkBufferUsageFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkBufferUsageFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkBufferUsageFlags(0)"); return ret; @@ -7286,14 +7286,14 @@ static inline const char* string_VkImageViewCreateFlagBits(VkImageViewCreateFlag #ifdef __cplusplus static inline std::string string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageViewCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageViewCreateFlags(0)"); return ret; @@ -7367,14 +7367,14 @@ static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value) #ifdef __cplusplus static inline std::string string_VkAccessFlags(VkAccessFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAccessFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAccessFlags(0)"); return ret; @@ -7402,14 +7402,14 @@ static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input #ifdef __cplusplus static inline std::string string_VkDependencyFlags(VkDependencyFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDependencyFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDependencyFlags(0)"); return ret; @@ -7431,14 +7431,14 @@ static inline const char* string_VkCommandPoolCreateFlagBits(VkCommandPoolCreate #ifdef __cplusplus static inline std::string string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCommandPoolCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCommandPoolCreateFlags(0)"); return ret; @@ -7456,14 +7456,14 @@ static inline const char* string_VkCommandPoolResetFlagBits(VkCommandPoolResetFl #ifdef __cplusplus static inline std::string string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCommandPoolResetFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCommandPoolResetFlags(0)"); return ret; @@ -7481,14 +7481,14 @@ static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits i #ifdef __cplusplus static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkQueryControlFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkQueryControlFlags(0)"); return ret; @@ -7510,14 +7510,14 @@ static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsa #ifdef __cplusplus static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCommandBufferUsageFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCommandBufferUsageFlags(0)"); return ret; @@ -7535,14 +7535,14 @@ static inline const char* string_VkCommandBufferResetFlagBits(VkCommandBufferRes #ifdef __cplusplus static inline std::string string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCommandBufferResetFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCommandBufferResetFlags(0)"); return ret; @@ -7560,14 +7560,14 @@ static inline const char* string_VkEventCreateFlagBits(VkEventCreateFlagBits inp #ifdef __cplusplus static inline std::string string_VkEventCreateFlags(VkEventCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkEventCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkEventCreateFlags(0)"); return ret; @@ -7587,14 +7587,14 @@ static inline const char* string_VkPipelineCacheCreateFlagBits(VkPipelineCacheCr #ifdef __cplusplus static inline std::string string_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineCacheCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineCacheCreateFlags(0)"); return ret; @@ -7674,14 +7674,14 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi #ifdef __cplusplus static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineCreateFlags(0)"); return ret; @@ -7701,14 +7701,14 @@ static inline const char* string_VkPipelineLayoutCreateFlagBits(VkPipelineLayout #ifdef __cplusplus static inline std::string string_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineLayoutCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineLayoutCreateFlags(0)"); return ret; @@ -7728,14 +7728,14 @@ static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineS #ifdef __cplusplus static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineShaderStageCreateFlags(0)"); return ret; @@ -7761,14 +7761,14 @@ static inline const char* string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits #ifdef __cplusplus static inline std::string string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSamplerCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSamplerCreateFlags(0)"); return ret; @@ -7794,14 +7794,14 @@ static inline const char* string_VkDescriptorPoolCreateFlagBits(VkDescriptorPool #ifdef __cplusplus static inline std::string string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDescriptorPoolCreateFlags(0)"); return ret; @@ -7831,14 +7831,14 @@ static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescripto #ifdef __cplusplus static inline std::string string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDescriptorSetLayoutCreateFlags(0)"); return ret; @@ -7862,14 +7862,14 @@ static inline const char* string_VkColorComponentFlagBits(VkColorComponentFlagBi #ifdef __cplusplus static inline std::string string_VkColorComponentFlags(VkColorComponentFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkColorComponentFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkColorComponentFlags(0)"); return ret; @@ -7894,14 +7894,14 @@ static inline const char* string_VkCullModeFlagBits(VkCullModeFlagBits input_val static inline std::string string_VkCullModeFlags(VkCullModeFlags input_value) { if (input_value == VK_CULL_MODE_FRONT_AND_BACK) { return "VK_CULL_MODE_FRONT_AND_BACK"; } std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCullModeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCullModeFlags(0)"); return ret; @@ -7919,14 +7919,14 @@ static inline const char* string_VkPipelineColorBlendStateCreateFlagBits(VkPipel #ifdef __cplusplus static inline std::string string_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineColorBlendStateCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineColorBlendStateCreateFlags(0)"); return ret; @@ -7946,14 +7946,14 @@ static inline const char* string_VkPipelineDepthStencilStateCreateFlagBits(VkPip #ifdef __cplusplus static inline std::string string_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineDepthStencilStateCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineDepthStencilStateCreateFlags(0)"); return ret; @@ -7975,14 +7975,14 @@ static inline const char* string_VkAttachmentDescriptionFlagBits(VkAttachmentDes #ifdef __cplusplus static inline std::string string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAttachmentDescriptionFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAttachmentDescriptionFlags(0)"); return ret; @@ -8000,14 +8000,14 @@ static inline const char* string_VkFramebufferCreateFlagBits(VkFramebufferCreate #ifdef __cplusplus static inline std::string string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFramebufferCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFramebufferCreateFlags(0)"); return ret; @@ -8027,14 +8027,14 @@ static inline const char* string_VkRenderPassCreateFlagBits(VkRenderPassCreateFl #ifdef __cplusplus static inline std::string string_VkRenderPassCreateFlags(VkRenderPassCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkRenderPassCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkRenderPassCreateFlags(0)"); return ret; @@ -8068,14 +8068,14 @@ static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescripti #ifdef __cplusplus static inline std::string string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSubpassDescriptionFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSubpassDescriptionFlags(0)"); return ret; @@ -8098,14 +8098,14 @@ static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits inp static inline std::string string_VkStencilFaceFlags(VkStencilFaceFlags input_value) { if (input_value == VK_STENCIL_FACE_FRONT_AND_BACK) { return "VK_STENCIL_FACE_FRONT_AND_BACK"; } std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkStencilFaceFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkStencilFaceFlags(0)"); return ret; @@ -8143,14 +8143,14 @@ static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlag #ifdef __cplusplus static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSubgroupFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSubgroupFeatureFlags(0)"); return ret; @@ -8174,14 +8174,14 @@ static inline const char* string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeature #ifdef __cplusplus static inline std::string string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPeerMemoryFeatureFlags(0)"); return ret; @@ -8205,14 +8205,14 @@ static inline const char* string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBi #ifdef __cplusplus static inline std::string string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryAllocateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryAllocateFlags(0)"); return ret; @@ -8264,14 +8264,14 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMe #ifdef __cplusplus static inline std::string string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalMemoryHandleTypeFlags(0)"); return ret; @@ -8293,14 +8293,14 @@ static inline const char* string_VkExternalMemoryFeatureFlagBits(VkExternalMemor #ifdef __cplusplus static inline std::string string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalMemoryFeatureFlags(0)"); return ret; @@ -8324,14 +8324,14 @@ static inline const char* string_VkExternalFenceHandleTypeFlagBits(VkExternalFen #ifdef __cplusplus static inline std::string string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalFenceHandleTypeFlags(0)"); return ret; @@ -8351,14 +8351,14 @@ static inline const char* string_VkExternalFenceFeatureFlagBits(VkExternalFenceF #ifdef __cplusplus static inline std::string string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalFenceFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalFenceFeatureFlags(0)"); return ret; @@ -8376,14 +8376,14 @@ static inline const char* string_VkFenceImportFlagBits(VkFenceImportFlagBits inp #ifdef __cplusplus static inline std::string string_VkFenceImportFlags(VkFenceImportFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFenceImportFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFenceImportFlags(0)"); return ret; @@ -8401,14 +8401,14 @@ static inline const char* string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlag #ifdef __cplusplus static inline std::string string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSemaphoreImportFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSemaphoreImportFlags(0)"); return ret; @@ -8436,14 +8436,14 @@ static inline const char* string_VkExternalSemaphoreHandleTypeFlagBits(VkExterna #ifdef __cplusplus static inline std::string string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalSemaphoreHandleTypeFlags(0)"); return ret; @@ -8463,14 +8463,14 @@ static inline const char* string_VkExternalSemaphoreFeatureFlagBits(VkExternalSe #ifdef __cplusplus static inline std::string string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalSemaphoreFeatureFlags(0)"); return ret; @@ -8500,14 +8500,14 @@ static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits inp #ifdef __cplusplus static inline std::string string_VkResolveModeFlags(VkResolveModeFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkResolveModeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkResolveModeFlags(0)"); return ret; @@ -8525,14 +8525,14 @@ static inline const char* string_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits #ifdef __cplusplus static inline std::string string_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSemaphoreWaitFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSemaphoreWaitFlags(0)"); return ret; @@ -8556,14 +8556,14 @@ static inline const char* string_VkDescriptorBindingFlagBits(VkDescriptorBinding #ifdef __cplusplus static inline std::string string_VkDescriptorBindingFlags(VkDescriptorBindingFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDescriptorBindingFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDescriptorBindingFlags(0)"); return ret; @@ -8593,14 +8593,14 @@ static inline const char* string_VkToolPurposeFlagBits(VkToolPurposeFlagBits inp #ifdef __cplusplus static inline std::string string_VkToolPurposeFlags(VkToolPurposeFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkToolPurposeFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkToolPurposeFlags(0)"); return ret; @@ -8618,14 +8618,14 @@ static inline const char* string_VkPrivateDataSlotCreateFlagBits(VkPrivateDataSl #ifdef __cplusplus static inline std::string string_VkPrivateDataSlotCreateFlags(VkPrivateDataSlotCreateFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPrivateDataSlotCreateFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPrivateDataSlotCreateFlags(0)"); return ret; @@ -8684,14 +8684,14 @@ static inline const char* string_VkPipelineStageFlagBits2(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkPipelineStageFlags2(VkPipelineStageFlags2 input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineStageFlagBits2(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineStageFlags2(0)"); return ret; @@ -8755,14 +8755,14 @@ static inline const char* string_VkAccessFlagBits2(uint64_t input_value) { #ifdef __cplusplus static inline std::string string_VkAccessFlags2(VkAccessFlags2 input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAccessFlagBits2(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAccessFlags2(0)"); return ret; @@ -8780,14 +8780,14 @@ static inline const char* string_VkSubmitFlagBits(VkSubmitFlagBits input_value) #ifdef __cplusplus static inline std::string string_VkSubmitFlags(VkSubmitFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSubmitFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSubmitFlags(0)"); return ret; @@ -8859,14 +8859,14 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkFormatFeatureFlags2(VkFormatFeatureFlags2 input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFormatFeatureFlagBits2(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFormatFeatureFlags2(0)"); return ret; @@ -8888,14 +8888,14 @@ static inline const char* string_VkPipelineCreationFeedbackFlagBits(VkPipelineCr #ifdef __cplusplus static inline std::string string_VkPipelineCreationFeedbackFlags(VkPipelineCreationFeedbackFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineCreationFeedbackFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineCreationFeedbackFlags(0)"); return ret; @@ -8929,14 +8929,14 @@ static inline const char* string_VkRenderingFlagBits(VkRenderingFlagBits input_v #ifdef __cplusplus static inline std::string string_VkRenderingFlags(VkRenderingFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkRenderingFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkRenderingFlags(0)"); return ret; @@ -8954,14 +8954,14 @@ static inline const char* string_VkMemoryUnmapFlagBits(VkMemoryUnmapFlagBits inp #ifdef __cplusplus static inline std::string string_VkMemoryUnmapFlags(VkMemoryUnmapFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryUnmapFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryUnmapFlags(0)"); return ret; @@ -9010,14 +9010,14 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) { #ifdef __cplusplus static inline std::string string_VkBufferUsageFlags2(VkBufferUsageFlags2 input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkBufferUsageFlagBits2(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkBufferUsageFlags2(0)"); return ret; @@ -9035,14 +9035,14 @@ static inline const char* string_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits #ifdef __cplusplus static inline std::string string_VkHostImageCopyFlags(VkHostImageCopyFlags input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkHostImageCopyFlagBits(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkHostImageCopyFlags(0)"); return ret; @@ -9101,14 +9101,14 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkPipelineCreateFlags2(VkPipelineCreateFlags2 input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPipelineCreateFlagBits2(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPipelineCreateFlags2(0)"); return ret; @@ -9142,14 +9142,14 @@ static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransfor #ifdef __cplusplus static inline std::string string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSurfaceTransformFlagsKHR(0)"); return ret; @@ -9173,14 +9173,14 @@ static inline const char* string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFla #ifdef __cplusplus static inline std::string string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCompositeAlphaFlagsKHR(0)"); return ret; @@ -9212,14 +9212,14 @@ static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateF #ifdef __cplusplus static inline std::string string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSwapchainCreateFlagsKHR(0)"); return ret; @@ -9243,14 +9243,14 @@ static inline const char* string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGro #ifdef __cplusplus static inline std::string string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDeviceGroupPresentModeFlagsKHR(0)"); return ret; @@ -9274,14 +9274,14 @@ static inline const char* string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAl #ifdef __cplusplus static inline std::string string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDisplayPlaneAlphaFlagsKHR(0)"); return ret; @@ -9313,14 +9313,14 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp #ifdef __cplusplus static inline std::string string_VkVideoCodecOperationFlagsKHR(VkVideoCodecOperationFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoCodecOperationFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoCodecOperationFlagsKHR(0)"); return ret; @@ -9346,14 +9346,14 @@ static inline const char* string_VkVideoChromaSubsamplingFlagBitsKHR(VkVideoChro #ifdef __cplusplus static inline std::string string_VkVideoChromaSubsamplingFlagsKHR(VkVideoChromaSubsamplingFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoChromaSubsamplingFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoChromaSubsamplingFlagsKHR(0)"); return ret; @@ -9377,14 +9377,14 @@ static inline const char* string_VkVideoComponentBitDepthFlagBitsKHR(VkVideoComp #ifdef __cplusplus static inline std::string string_VkVideoComponentBitDepthFlagsKHR(VkVideoComponentBitDepthFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoComponentBitDepthFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoComponentBitDepthFlagsKHR(0)"); return ret; @@ -9404,14 +9404,14 @@ static inline const char* string_VkVideoCapabilityFlagBitsKHR(VkVideoCapabilityF #ifdef __cplusplus static inline std::string string_VkVideoCapabilityFlagsKHR(VkVideoCapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoCapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoCapabilityFlagsKHR(0)"); return ret; @@ -9439,14 +9439,14 @@ static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionC #ifdef __cplusplus static inline std::string string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCreateFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoSessionCreateFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoSessionCreateFlagsKHR(0)"); return ret; @@ -9464,14 +9464,14 @@ static inline const char* string_VkVideoSessionParametersCreateFlagBitsKHR(VkVid #ifdef __cplusplus static inline std::string string_VkVideoSessionParametersCreateFlagsKHR(VkVideoSessionParametersCreateFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoSessionParametersCreateFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoSessionParametersCreateFlagsKHR(0)"); return ret; @@ -9493,14 +9493,14 @@ static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingCo #ifdef __cplusplus static inline std::string string_VkVideoCodingControlFlagsKHR(VkVideoCodingControlFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoCodingControlFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoCodingControlFlagsKHR(0)"); return ret; @@ -9520,14 +9520,14 @@ static inline const char* string_VkVideoDecodeCapabilityFlagBitsKHR(VkVideoDecod #ifdef __cplusplus static inline std::string string_VkVideoDecodeCapabilityFlagsKHR(VkVideoDecodeCapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoDecodeCapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoDecodeCapabilityFlagsKHR(0)"); return ret; @@ -9551,14 +9551,14 @@ static inline const char* string_VkVideoDecodeUsageFlagBitsKHR(VkVideoDecodeUsag #ifdef __cplusplus static inline std::string string_VkVideoDecodeUsageFlagsKHR(VkVideoDecodeUsageFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoDecodeUsageFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoDecodeUsageFlagsKHR(0)"); return ret; @@ -9596,14 +9596,14 @@ static inline const char* string_VkVideoEncodeH264CapabilityFlagBitsKHR(VkVideoE #ifdef __cplusplus static inline std::string string_VkVideoEncodeH264CapabilityFlagsKHR(VkVideoEncodeH264CapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH264CapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH264CapabilityFlagsKHR(0)"); return ret; @@ -9659,14 +9659,14 @@ static inline const char* string_VkVideoEncodeH264StdFlagBitsKHR(VkVideoEncodeH2 #ifdef __cplusplus static inline std::string string_VkVideoEncodeH264StdFlagsKHR(VkVideoEncodeH264StdFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH264StdFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH264StdFlagsKHR(0)"); return ret; @@ -9692,14 +9692,14 @@ static inline const char* string_VkVideoEncodeH264RateControlFlagBitsKHR(VkVideo #ifdef __cplusplus static inline std::string string_VkVideoEncodeH264RateControlFlagsKHR(VkVideoEncodeH264RateControlFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH264RateControlFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH264RateControlFlagsKHR(0)"); return ret; @@ -9739,14 +9739,14 @@ static inline const char* string_VkVideoEncodeH265CapabilityFlagBitsKHR(VkVideoE #ifdef __cplusplus static inline std::string string_VkVideoEncodeH265CapabilityFlagsKHR(VkVideoEncodeH265CapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH265CapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH265CapabilityFlagsKHR(0)"); return ret; @@ -9804,14 +9804,14 @@ static inline const char* string_VkVideoEncodeH265StdFlagBitsKHR(VkVideoEncodeH2 #ifdef __cplusplus static inline std::string string_VkVideoEncodeH265StdFlagsKHR(VkVideoEncodeH265StdFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH265StdFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH265StdFlagsKHR(0)"); return ret; @@ -9833,14 +9833,14 @@ static inline const char* string_VkVideoEncodeH265CtbSizeFlagBitsKHR(VkVideoEnco #ifdef __cplusplus static inline std::string string_VkVideoEncodeH265CtbSizeFlagsKHR(VkVideoEncodeH265CtbSizeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH265CtbSizeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH265CtbSizeFlagsKHR(0)"); return ret; @@ -9864,14 +9864,14 @@ static inline const char* string_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR( #ifdef __cplusplus static inline std::string string_VkVideoEncodeH265TransformBlockSizeFlagsKHR(VkVideoEncodeH265TransformBlockSizeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH265TransformBlockSizeFlagsKHR(0)"); return ret; @@ -9897,14 +9897,14 @@ static inline const char* string_VkVideoEncodeH265RateControlFlagBitsKHR(VkVideo #ifdef __cplusplus static inline std::string string_VkVideoEncodeH265RateControlFlagsKHR(VkVideoEncodeH265RateControlFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeH265RateControlFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeH265RateControlFlagsKHR(0)"); return ret; @@ -9926,14 +9926,14 @@ static inline const char* string_VkVideoDecodeH264PictureLayoutFlagBitsKHR(VkVid #ifdef __cplusplus static inline std::string string_VkVideoDecodeH264PictureLayoutFlagsKHR(VkVideoDecodeH264PictureLayoutFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoDecodeH264PictureLayoutFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoDecodeH264PictureLayoutFlagsKHR(0)"); return ret; @@ -9953,14 +9953,14 @@ static inline const char* string_VkPerformanceCounterDescriptionFlagBitsKHR(VkPe #ifdef __cplusplus static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPerformanceCounterDescriptionFlagsKHR(0)"); return ret; @@ -9982,14 +9982,14 @@ static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsK #ifdef __cplusplus static inline std::string string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeFlagsKHR(0)"); return ret; @@ -10013,14 +10013,14 @@ static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncod #ifdef __cplusplus static inline std::string string_VkVideoEncodeCapabilityFlagsKHR(VkVideoEncodeCapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeCapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeCapabilityFlagsKHR(0)"); return ret; @@ -10044,14 +10044,14 @@ static inline const char* string_VkVideoEncodeRateControlModeFlagBitsKHR(VkVideo #ifdef __cplusplus static inline std::string string_VkVideoEncodeRateControlModeFlagsKHR(VkVideoEncodeRateControlModeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeRateControlModeFlagsKHR(0)"); return ret; @@ -10087,14 +10087,14 @@ static inline const char* string_VkVideoEncodeFeedbackFlagBitsKHR(VkVideoEncodeF #ifdef __cplusplus static inline std::string string_VkVideoEncodeFeedbackFlagsKHR(VkVideoEncodeFeedbackFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeFeedbackFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeFeedbackFlagsKHR(0)"); return ret; @@ -10120,14 +10120,14 @@ static inline const char* string_VkVideoEncodeUsageFlagBitsKHR(VkVideoEncodeUsag #ifdef __cplusplus static inline std::string string_VkVideoEncodeUsageFlagsKHR(VkVideoEncodeUsageFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeUsageFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeUsageFlagsKHR(0)"); return ret; @@ -10151,14 +10151,14 @@ static inline const char* string_VkVideoEncodeContentFlagBitsKHR(VkVideoEncodeCo #ifdef __cplusplus static inline std::string string_VkVideoEncodeContentFlagsKHR(VkVideoEncodeContentFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeContentFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeContentFlagsKHR(0)"); return ret; @@ -10186,14 +10186,14 @@ static inline const char* string_VkAddressCommandFlagBitsKHR(VkAddressCommandFla #ifdef __cplusplus static inline std::string string_VkAddressCommandFlagsKHR(VkAddressCommandFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAddressCommandFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAddressCommandFlagsKHR(0)"); return ret; @@ -10211,14 +10211,14 @@ static inline const char* string_VkConditionalRenderingFlagBitsEXT(VkConditional #ifdef __cplusplus static inline std::string string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkConditionalRenderingFlagsEXT(0)"); return ret; @@ -10240,14 +10240,14 @@ static inline const char* string_VkAccelerationStructureCreateFlagBitsKHR(VkAcce #ifdef __cplusplus static inline std::string string_VkAccelerationStructureCreateFlagsKHR(VkAccelerationStructureCreateFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAccelerationStructureCreateFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAccelerationStructureCreateFlagsKHR(0)"); return ret; @@ -10269,14 +10269,14 @@ static inline const char* string_VkPresentScalingFlagBitsKHR(VkPresentScalingFla #ifdef __cplusplus static inline std::string string_VkPresentScalingFlagsKHR(VkPresentScalingFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPresentScalingFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPresentScalingFlagsKHR(0)"); return ret; @@ -10298,14 +10298,14 @@ static inline const char* string_VkPresentGravityFlagBitsKHR(VkPresentGravityFla #ifdef __cplusplus static inline std::string string_VkPresentGravityFlagsKHR(VkPresentGravityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPresentGravityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPresentGravityFlagsKHR(0)"); return ret; @@ -10333,14 +10333,14 @@ static inline const char* string_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEn #ifdef __cplusplus static inline std::string string_VkVideoEncodeAV1CapabilityFlagsKHR(VkVideoEncodeAV1CapabilityFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeAV1CapabilityFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeAV1CapabilityFlagsKHR(0)"); return ret; @@ -10364,14 +10364,14 @@ static inline const char* string_VkVideoEncodeAV1StdFlagBitsKHR(VkVideoEncodeAV1 #ifdef __cplusplus static inline std::string string_VkVideoEncodeAV1StdFlagsKHR(VkVideoEncodeAV1StdFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeAV1StdFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeAV1StdFlagsKHR(0)"); return ret; @@ -10391,14 +10391,14 @@ static inline const char* string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(VkVid #ifdef __cplusplus static inline std::string string_VkVideoEncodeAV1SuperblockSizeFlagsKHR(VkVideoEncodeAV1SuperblockSizeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeAV1SuperblockSizeFlagsKHR(0)"); return ret; @@ -10422,14 +10422,14 @@ static inline const char* string_VkVideoEncodeAV1RateControlFlagBitsKHR(VkVideoE #ifdef __cplusplus static inline std::string string_VkVideoEncodeAV1RateControlFlagsKHR(VkVideoEncodeAV1RateControlFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeAV1RateControlFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeAV1RateControlFlagsKHR(0)"); return ret; @@ -10451,14 +10451,14 @@ static inline const char* string_VkAddressCopyFlagBitsKHR(VkAddressCopyFlagBitsK #ifdef __cplusplus static inline std::string string_VkAddressCopyFlagsKHR(VkAddressCopyFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAddressCopyFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAddressCopyFlagsKHR(0)"); return ret; @@ -10484,14 +10484,14 @@ static inline const char* string_VkVideoEncodeIntraRefreshModeFlagBitsKHR(VkVide #ifdef __cplusplus static inline std::string string_VkVideoEncodeIntraRefreshModeFlagsKHR(VkVideoEncodeIntraRefreshModeFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeIntraRefreshModeFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeIntraRefreshModeFlagsKHR(0)"); return ret; @@ -10519,14 +10519,14 @@ static inline const char* string_VkDeviceFaultFlagBitsKHR(VkDeviceFaultFlagBitsK #ifdef __cplusplus static inline std::string string_VkDeviceFaultFlagsKHR(VkDeviceFaultFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDeviceFaultFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDeviceFaultFlagsKHR(0)"); return ret; @@ -10540,14 +10540,14 @@ static inline const char* string_VkAccessFlagBits3KHR(uint64_t input_value) { #ifdef __cplusplus static inline std::string string_VkAccessFlags3KHR(VkAccessFlags3KHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkAccessFlagBits3KHR(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkAccessFlags3KHR(0)"); return ret; @@ -10569,14 +10569,14 @@ static inline const char* string_VkVideoEncodePerPartitionFeedbackFlagBitsKHR(Vk #ifdef __cplusplus static inline std::string string_VkVideoEncodePerPartitionFeedbackFlagsKHR(VkVideoEncodePerPartitionFeedbackFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodePerPartitionFeedbackFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodePerPartitionFeedbackFlagsKHR(0)"); return ret; @@ -10598,14 +10598,14 @@ static inline const char* string_VkRenderingAttachmentFlagBitsKHR(VkRenderingAtt #ifdef __cplusplus static inline std::string string_VkRenderingAttachmentFlagsKHR(VkRenderingAttachmentFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkRenderingAttachmentFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkRenderingAttachmentFlagsKHR(0)"); return ret; @@ -10625,14 +10625,14 @@ static inline const char* string_VkResolveImageFlagBitsKHR(VkResolveImageFlagBit #ifdef __cplusplus static inline std::string string_VkResolveImageFlagsKHR(VkResolveImageFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkResolveImageFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkResolveImageFlagsKHR(0)"); return ret; @@ -10670,14 +10670,14 @@ static inline const char* string_VkImageUsageFlagBits2KHR(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkImageUsageFlags2KHR(VkImageUsageFlags2KHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageUsageFlagBits2KHR(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageUsageFlags2KHR(0)"); return ret; @@ -10711,14 +10711,14 @@ static inline const char* string_VkImageCreateFlagBits2KHR(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkImageCreateFlags2KHR(VkImageCreateFlags2KHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageCreateFlagBits2KHR(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageCreateFlags2KHR(0)"); return ret; @@ -10744,14 +10744,14 @@ static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsE #ifdef __cplusplus static inline std::string string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDebugReportFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDebugReportFlagsEXT(0)"); return ret; @@ -10775,14 +10775,14 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternal #ifdef __cplusplus static inline std::string string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalMemoryHandleTypeFlagsNV(0)"); return ret; @@ -10804,14 +10804,14 @@ static inline const char* string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMem #ifdef __cplusplus static inline std::string string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExternalMemoryFeatureFlagsNV(0)"); return ret; @@ -10829,14 +10829,14 @@ static inline const char* string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFla #ifdef __cplusplus static inline std::string string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSurfaceCounterFlagsEXT(0)"); return ret; @@ -10860,14 +10860,14 @@ static inline const char* string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugU #ifdef __cplusplus static inline std::string string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDebugUtilsMessageSeverityFlagsEXT(0)"); return ret; @@ -10891,14 +10891,14 @@ static inline const char* string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtils #ifdef __cplusplus static inline std::string string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDebugUtilsMessageTypeFlagsEXT(0)"); return ret; @@ -10928,14 +10928,14 @@ static inline const char* string_VkGpaSqShaderStageFlagBitsAMD(VkGpaSqShaderStag #ifdef __cplusplus static inline std::string string_VkGpaSqShaderStageFlagsAMD(VkGpaSqShaderStageFlagsAMD input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkGpaSqShaderStageFlagBitsAMD(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkGpaSqShaderStageFlagsAMD(0)"); return ret; @@ -10949,14 +10949,14 @@ static inline const char* string_VkTensorViewCreateFlagBitsARM(uint64_t input_va #ifdef __cplusplus static inline std::string string_VkTensorViewCreateFlagsARM(VkTensorViewCreateFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkTensorViewCreateFlagBitsARM(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkTensorViewCreateFlagsARM(0)"); return ret; @@ -10995,14 +10995,14 @@ static inline const char* string_VkSpirvResourceTypeFlagBitsEXT(VkSpirvResourceT static inline std::string string_VkSpirvResourceTypeFlagsEXT(VkSpirvResourceTypeFlagsEXT input_value) { if (input_value == VK_SPIRV_RESOURCE_TYPE_ALL_EXT) { return "VK_SPIRV_RESOURCE_TYPE_ALL_EXT"; } std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkSpirvResourceTypeFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkSpirvResourceTypeFlagsEXT(0)"); return ret; @@ -11022,14 +11022,14 @@ static inline const char* string_VkGeometryFlagBitsKHR(VkGeometryFlagBitsKHR inp #ifdef __cplusplus static inline std::string string_VkGeometryFlagsKHR(VkGeometryFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkGeometryFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkGeometryFlagsKHR(0)"); return ret; @@ -11057,14 +11057,14 @@ static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanc #ifdef __cplusplus static inline std::string string_VkGeometryInstanceFlagsKHR(VkGeometryInstanceFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkGeometryInstanceFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkGeometryInstanceFlagsKHR(0)"); return ret; @@ -11108,14 +11108,14 @@ static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuild #ifdef __cplusplus static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAccelerationStructureFlagsKHR input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkBuildAccelerationStructureFlagBitsKHR(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkBuildAccelerationStructureFlagsKHR(0)"); return ret; @@ -11139,14 +11139,14 @@ static inline const char* string_VkPresentStageFlagBitsEXT(VkPresentStageFlagBit #ifdef __cplusplus static inline std::string string_VkPresentStageFlagsEXT(VkPresentStageFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPresentStageFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPresentStageFlagsEXT(0)"); return ret; @@ -11166,14 +11166,14 @@ static inline const char* string_VkPastPresentationTimingFlagBitsEXT(VkPastPrese #ifdef __cplusplus static inline std::string string_VkPastPresentationTimingFlagsEXT(VkPastPresentationTimingFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPastPresentationTimingFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPastPresentationTimingFlagsEXT(0)"); return ret; @@ -11193,14 +11193,14 @@ static inline const char* string_VkPresentTimingInfoFlagBitsEXT(VkPresentTimingI #ifdef __cplusplus static inline std::string string_VkPresentTimingInfoFlagsEXT(VkPresentTimingInfoFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPresentTimingInfoFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPresentTimingInfoFlagsEXT(0)"); return ret; @@ -11218,14 +11218,14 @@ static inline const char* string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBi #ifdef __cplusplus static inline std::string string_VkIndirectStateFlagsNV(VkIndirectStateFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkIndirectStateFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkIndirectStateFlagsNV(0)"); return ret; @@ -11247,14 +11247,14 @@ static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsNV(VkIndir #ifdef __cplusplus static inline std::string string_VkIndirectCommandsLayoutUsageFlagsNV(VkIndirectCommandsLayoutUsageFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkIndirectCommandsLayoutUsageFlagsNV(0)"); return ret; @@ -11278,14 +11278,14 @@ static inline const char* string_VkDeviceDiagnosticsConfigFlagBitsNV(VkDeviceDia #ifdef __cplusplus static inline std::string string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagnosticsConfigFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDeviceDiagnosticsConfigFlagsNV(0)"); return ret; @@ -11305,14 +11305,14 @@ static inline const char* string_VkTileShadingRenderPassFlagBitsQCOM(VkTileShadi #ifdef __cplusplus static inline std::string string_VkTileShadingRenderPassFlagsQCOM(VkTileShadingRenderPassFlagsQCOM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkTileShadingRenderPassFlagBitsQCOM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkTileShadingRenderPassFlagsQCOM(0)"); return ret; @@ -11341,14 +11341,14 @@ static inline const char* string_VkExportMetalObjectTypeFlagBitsEXT(VkExportMeta #ifdef __cplusplus static inline std::string string_VkExportMetalObjectTypeFlagsEXT(VkExportMetalObjectTypeFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkExportMetalObjectTypeFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkExportMetalObjectTypeFlagsEXT(0)"); return ret; @@ -11373,14 +11373,14 @@ static inline const char* string_VkGraphicsPipelineLibraryFlagBitsEXT(VkGraphics #ifdef __cplusplus static inline std::string string_VkGraphicsPipelineLibraryFlagsEXT(VkGraphicsPipelineLibraryFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkGraphicsPipelineLibraryFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkGraphicsPipelineLibraryFlagsEXT(0)"); return ret; @@ -11404,14 +11404,14 @@ static inline const char* string_VkImageCompressionFlagBitsEXT(VkImageCompressio #ifdef __cplusplus static inline std::string string_VkImageCompressionFlagsEXT(VkImageCompressionFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageCompressionFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageCompressionFlagsEXT(0)"); return ret; @@ -11477,14 +11477,14 @@ static inline const char* string_VkImageCompressionFixedRateFlagBitsEXT(VkImageC #ifdef __cplusplus static inline std::string string_VkImageCompressionFixedRateFlagsEXT(VkImageCompressionFixedRateFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageCompressionFixedRateFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageCompressionFixedRateFlagsEXT(0)"); return ret; @@ -11502,14 +11502,14 @@ static inline const char* string_VkDeviceAddressBindingFlagBitsEXT(VkDeviceAddre #ifdef __cplusplus static inline std::string string_VkDeviceAddressBindingFlagsEXT(VkDeviceAddressBindingFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDeviceAddressBindingFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDeviceAddressBindingFlagsEXT(0)"); return ret; @@ -11536,14 +11536,14 @@ static inline const char* string_VkImageConstraintsInfoFlagBitsFUCHSIA(VkImageCo #ifdef __cplusplus static inline std::string string_VkImageConstraintsInfoFlagsFUCHSIA(VkImageConstraintsInfoFlagsFUCHSIA input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkImageConstraintsInfoFlagBitsFUCHSIA(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkImageConstraintsInfoFlagsFUCHSIA(0)"); return ret; @@ -11562,14 +11562,14 @@ static inline const char* string_VkFrameBoundaryFlagBitsEXT(VkFrameBoundaryFlagB #ifdef __cplusplus static inline std::string string_VkFrameBoundaryFlagsEXT(VkFrameBoundaryFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkFrameBoundaryFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkFrameBoundaryFlagsEXT(0)"); return ret; @@ -11595,14 +11595,14 @@ static inline const char* string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(Vk #ifdef __cplusplus static inline std::string string_VkVideoEncodeRgbModelConversionFlagsVALVE(VkVideoEncodeRgbModelConversionFlagsVALVE input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeRgbModelConversionFlagsVALVE(0)"); return ret; @@ -11622,14 +11622,14 @@ static inline const char* string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(V #ifdef __cplusplus static inline std::string string_VkVideoEncodeRgbRangeCompressionFlagsVALVE(VkVideoEncodeRgbRangeCompressionFlagsVALVE input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeRgbRangeCompressionFlagsVALVE(0)"); return ret; @@ -11649,14 +11649,14 @@ static inline const char* string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(VkVid #ifdef __cplusplus static inline std::string string_VkVideoEncodeRgbChromaOffsetFlagsVALVE(VkVideoEncodeRgbChromaOffsetFlagsVALVE input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkVideoEncodeRgbChromaOffsetFlagsVALVE(0)"); return ret; @@ -11678,14 +11678,14 @@ static inline const char* string_VkBuildMicromapFlagBitsEXT(VkBuildMicromapFlagB #ifdef __cplusplus static inline std::string string_VkBuildMicromapFlagsEXT(VkBuildMicromapFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkBuildMicromapFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkBuildMicromapFlagsEXT(0)"); return ret; @@ -11703,14 +11703,14 @@ static inline const char* string_VkMicromapCreateFlagBitsEXT(VkMicromapCreateFla #ifdef __cplusplus static inline std::string string_VkMicromapCreateFlagsEXT(VkMicromapCreateFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMicromapCreateFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMicromapCreateFlagsEXT(0)"); return ret; @@ -11725,14 +11725,14 @@ static inline const char* string_VkPhysicalDeviceSchedulingControlsFlagBitsARM(u #ifdef __cplusplus static inline std::string string_VkPhysicalDeviceSchedulingControlsFlagsARM(VkPhysicalDeviceSchedulingControlsFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPhysicalDeviceSchedulingControlsFlagBitsARM(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPhysicalDeviceSchedulingControlsFlagsARM(0)"); return ret; @@ -11746,14 +11746,14 @@ static inline const char* string_VkMemoryDecompressionMethodFlagBitsEXT(uint64_t #ifdef __cplusplus static inline std::string string_VkMemoryDecompressionMethodFlagsEXT(VkMemoryDecompressionMethodFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkMemoryDecompressionMethodFlagBitsEXT(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkMemoryDecompressionMethodFlagsEXT(0)"); return ret; @@ -11770,14 +11770,14 @@ static inline const char* string_VkTensorCreateFlagBitsARM(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkTensorCreateFlagsARM(VkTensorCreateFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkTensorCreateFlagBitsARM(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkTensorCreateFlagsARM(0)"); return ret; @@ -11795,14 +11795,14 @@ static inline const char* string_VkTensorUsageFlagBitsARM(uint64_t input_value) #ifdef __cplusplus static inline std::string string_VkTensorUsageFlagsARM(VkTensorUsageFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkTensorUsageFlagBitsARM(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkTensorUsageFlagsARM(0)"); return ret; @@ -11828,14 +11828,14 @@ static inline const char* string_VkOpticalFlowGridSizeFlagBitsNV(VkOpticalFlowGr #ifdef __cplusplus static inline std::string string_VkOpticalFlowGridSizeFlagsNV(VkOpticalFlowGridSizeFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkOpticalFlowGridSizeFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkOpticalFlowGridSizeFlagsNV(0)"); return ret; @@ -11863,14 +11863,14 @@ static inline const char* string_VkOpticalFlowUsageFlagBitsNV(VkOpticalFlowUsage #ifdef __cplusplus static inline std::string string_VkOpticalFlowUsageFlagsNV(VkOpticalFlowUsageFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkOpticalFlowUsageFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkOpticalFlowUsageFlagsNV(0)"); return ret; @@ -11896,14 +11896,14 @@ static inline const char* string_VkOpticalFlowSessionCreateFlagBitsNV(VkOpticalF #ifdef __cplusplus static inline std::string string_VkOpticalFlowSessionCreateFlagsNV(VkOpticalFlowSessionCreateFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkOpticalFlowSessionCreateFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkOpticalFlowSessionCreateFlagsNV(0)"); return ret; @@ -11921,14 +11921,14 @@ static inline const char* string_VkOpticalFlowExecuteFlagBitsNV(VkOpticalFlowExe #ifdef __cplusplus static inline std::string string_VkOpticalFlowExecuteFlagsNV(VkOpticalFlowExecuteFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkOpticalFlowExecuteFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkOpticalFlowExecuteFlagsNV(0)"); return ret; @@ -11970,14 +11970,14 @@ static inline const char* string_VkShaderCreateFlagBitsEXT(VkShaderCreateFlagBit #ifdef __cplusplus static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkShaderCreateFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkShaderCreateFlagsEXT(0)"); return ret; @@ -11992,14 +11992,14 @@ static inline const char* string_VkDataGraphPipelineSessionCreateFlagBitsARM(uin #ifdef __cplusplus static inline std::string string_VkDataGraphPipelineSessionCreateFlagsARM(VkDataGraphPipelineSessionCreateFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphPipelineSessionCreateFlagBitsARM(static_cast(1ULL << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphPipelineSessionCreateFlagsARM(0)"); return ret; @@ -12023,14 +12023,14 @@ static inline const char* string_VkDataGraphTOSAQualityFlagBitsARM(VkDataGraphTO #ifdef __cplusplus static inline std::string string_VkDataGraphTOSAQualityFlagsARM(VkDataGraphTOSAQualityFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphTOSAQualityFlagBitsARM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphTOSAQualityFlagsARM(0)"); return ret; @@ -12060,14 +12060,14 @@ static inline const char* string_VkClusterAccelerationStructureAddressResolution #ifdef __cplusplus static inline std::string string_VkClusterAccelerationStructureAddressResolutionFlagsNV(VkClusterAccelerationStructureAddressResolutionFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkClusterAccelerationStructureAddressResolutionFlagsNV(0)"); return ret; @@ -12085,14 +12085,14 @@ static inline const char* string_VkClusterAccelerationStructureClusterFlagBitsNV #ifdef __cplusplus static inline std::string string_VkClusterAccelerationStructureClusterFlagsNV(VkClusterAccelerationStructureClusterFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkClusterAccelerationStructureClusterFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkClusterAccelerationStructureClusterFlagsNV(0)"); return ret; @@ -12114,14 +12114,14 @@ static inline const char* string_VkClusterAccelerationStructureGeometryFlagBitsN #ifdef __cplusplus static inline std::string string_VkClusterAccelerationStructureGeometryFlagsNV(VkClusterAccelerationStructureGeometryFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkClusterAccelerationStructureGeometryFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkClusterAccelerationStructureGeometryFlagsNV(0)"); return ret; @@ -12143,14 +12143,14 @@ static inline const char* string_VkClusterAccelerationStructureIndexFormatFlagBi #ifdef __cplusplus static inline std::string string_VkClusterAccelerationStructureIndexFormatFlagsNV(VkClusterAccelerationStructureIndexFormatFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkClusterAccelerationStructureIndexFormatFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkClusterAccelerationStructureIndexFormatFlagsNV(0)"); return ret; @@ -12176,14 +12176,14 @@ static inline const char* string_VkPartitionedAccelerationStructureInstanceFlagB #ifdef __cplusplus static inline std::string string_VkPartitionedAccelerationStructureInstanceFlagsNV(VkPartitionedAccelerationStructureInstanceFlagsNV input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkPartitionedAccelerationStructureInstanceFlagBitsNV(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkPartitionedAccelerationStructureInstanceFlagsNV(0)"); return ret; @@ -12203,14 +12203,14 @@ static inline const char* string_VkIndirectCommandsInputModeFlagBitsEXT(VkIndire #ifdef __cplusplus static inline std::string string_VkIndirectCommandsInputModeFlagsEXT(VkIndirectCommandsInputModeFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkIndirectCommandsInputModeFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkIndirectCommandsInputModeFlagsEXT(0)"); return ret; @@ -12230,14 +12230,14 @@ static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsEXT(VkIndi #ifdef __cplusplus static inline std::string string_VkIndirectCommandsLayoutUsageFlagsEXT(VkIndirectCommandsLayoutUsageFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkIndirectCommandsLayoutUsageFlagsEXT(0)"); return ret; @@ -12263,14 +12263,14 @@ static inline const char* string_VkDataGraphOpticalFlowGridSizeFlagBitsARM(VkDat #ifdef __cplusplus static inline std::string string_VkDataGraphOpticalFlowGridSizeFlagsARM(VkDataGraphOpticalFlowGridSizeFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphOpticalFlowGridSizeFlagBitsARM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphOpticalFlowGridSizeFlagsARM(0)"); return ret; @@ -12292,14 +12292,14 @@ static inline const char* string_VkDataGraphOpticalFlowCreateFlagBitsARM(VkDataG #ifdef __cplusplus static inline std::string string_VkDataGraphOpticalFlowCreateFlagsARM(VkDataGraphOpticalFlowCreateFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphOpticalFlowCreateFlagBitsARM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphOpticalFlowCreateFlagsARM(0)"); return ret; @@ -12325,14 +12325,14 @@ static inline const char* string_VkDataGraphOpticalFlowImageUsageFlagBitsARM(VkD #ifdef __cplusplus static inline std::string string_VkDataGraphOpticalFlowImageUsageFlagsARM(VkDataGraphOpticalFlowImageUsageFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphOpticalFlowImageUsageFlagBitsARM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphOpticalFlowImageUsageFlagsARM(0)"); return ret; @@ -12358,14 +12358,14 @@ static inline const char* string_VkDataGraphOpticalFlowExecuteFlagBitsARM(VkData #ifdef __cplusplus static inline std::string string_VkDataGraphOpticalFlowExecuteFlagsARM(VkDataGraphOpticalFlowExecuteFlagsARM input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkDataGraphOpticalFlowExecuteFlagBitsARM(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkDataGraphOpticalFlowExecuteFlagsARM(0)"); return ret; @@ -12383,14 +12383,14 @@ static inline const char* string_VkCooperativeMatrixFlagBitsEXT(VkCooperativeMat #ifdef __cplusplus static inline std::string string_VkCooperativeMatrixFlagsEXT(VkCooperativeMatrixFlagsEXT input_value) { std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) { - if (input_value & 1) { + if (input_value & 1u) { if( !ret.empty()) ret.append("|"); ret.append(string_VkCooperativeMatrixFlagBitsEXT(static_cast(1U << index))); } ++index; - input_value >>= 1; + input_value >>= 1u; } if (ret.empty()) ret.append("VkCooperativeMatrixFlagsEXT(0)"); return ret; diff --git a/scripts/generators/enum_string_helper_generator.py b/scripts/generators/enum_string_helper_generator.py index b1a89205..5ed206bc 100644 --- a/scripts/generators/enum_string_helper_generator.py +++ b/scripts/generators/enum_string_helper_generator.py @@ -97,14 +97,14 @@ def generate(self): out.append(f''' static inline std::string string_{bitmask.flagName}({bitmask.flagName} input_value) {{ {multiBitChecks} std::string ret; - int index = 0; + unsigned int index = 0; while(input_value) {{ - if (input_value & 1) {{ + if (input_value & 1u) {{ if( !ret.empty()) ret.append("|"); ret.append(string_{bitmask.name}(static_cast<{groupType}>(1{intSuffix} << index))); }} ++index; - input_value >>= 1; + input_value >>= 1u; }} if (ret.empty()) ret.append("{bitmask.flagName}(0)"); return ret; diff --git a/tests/test_setting_api.cpp b/tests/test_setting_api.cpp index e321aa28..b795d6c9 100644 --- a/tests/test_setting_api.cpp +++ b/tests/test_setting_api.cpp @@ -108,7 +108,7 @@ TEST(test_layer_setting_api, vkuHasLayerSetting) { setting_int32_value.valueCount = 1; settings.push_back(setting_int32_value); - std::int64_t value_int64 = static_cast(1) << static_cast(40); + std::int64_t value_int64 = static_cast(1) << static_cast(40); VkLayerSettingEXT setting_int64_value{}; setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int64_value.pSettingName = "int64_value"; diff --git a/tests/test_setting_cpp.cpp b/tests/test_setting_cpp.cpp index c80a3f19..cf702adc 100644 --- a/tests/test_setting_cpp.cpp +++ b/tests/test_setting_cpp.cpp @@ -504,7 +504,7 @@ TEST(test_layer_setting_cpp, vkuGetUnknownSettings_legacy) { setting_int32_value.valueCount = 1; settings.push_back(setting_int32_value); - std::int64_t value_int64 = static_cast(1) << static_cast(40); + std::int64_t value_int64 = static_cast(1) << static_cast(40); VkLayerSettingEXT setting_int64_value{}; setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int64_value.pSettingName = "int64_value"; diff --git a/tests/test_setting_util.cpp b/tests/test_setting_util.cpp index 66809722..b7bc8ed7 100644 --- a/tests/test_setting_util.cpp +++ b/tests/test_setting_util.cpp @@ -599,7 +599,7 @@ TEST(test_layer_settings_util, vkuGetUnknownSettings_SingleCreateInfo) { setting_int32_value.valueCount = 1; settings.push_back(setting_int32_value); - std::int64_t value_int64 = static_cast(1) << static_cast(40); + std::int64_t value_int64 = static_cast(1) << static_cast(40); VkLayerSettingEXT setting_int64_value{}; setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int64_value.pSettingName = "int64_value"; @@ -708,7 +708,7 @@ TEST(test_layer_settings_util, vlGetUnknownSettings_MultipleCreateInfo) { setting_int32_value.valueCount = 1; settingsA.push_back(setting_int32_value); - std::int64_t value_int64 = static_cast(1) << static_cast(40); + std::int64_t value_int64 = static_cast(1) << static_cast(40); VkLayerSettingEXT setting_int64_value{}; setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int64_value.pSettingName = "int64_value"; From b4f3b3f2d4784a296be422bafa06c2af3d6ceaa0 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 12:17:04 -0500 Subject: [PATCH 12/13] Add clang-tidy and fixes for it Adds the CMake build option USE_CLANG_TIDY that enables clang-tidy checks. The .clang-tidy file configures the settings to apply everywhere while the tests/.clang-tidy only applies to the tests, that way nuisance checks can be disabled for tests (such as const correctness). format.yml was renamed to lint.yml as it now contains a step to run the project with clang-tidy enabled. --- .clang-tidy | 34 +++++++++++++++++++ .github/workflows/{format.yml => lint.yml} | 25 +++++++++++++- CMakeLists.txt | 10 ++++++ .../vulkan/utility/vk_small_containers.hpp | 4 +-- .../vulkan/utility/vk_sparse_range_map.hpp | 6 ++-- src/layer/layer_settings_manager.cpp | 5 +-- src/layer/layer_settings_util.cpp | 10 ++++-- src/layer/vk_layer_settings.cpp | 5 +++ src/layer/vk_layer_settings_helper.cpp | 2 +- tests/.clang-tidy | 9 +++++ tests/small_containers.cpp | 9 ++--- tests/struct_helper.cpp | 2 ++ tests/test_formats.cpp | 2 +- tests/test_interface.cpp | 4 +-- tests/test_setting_cast.cpp | 1 + tests/test_setting_env.cpp | 2 +- tests/vk_enum_string_helper.cpp | 14 ++++---- 17 files changed, 116 insertions(+), 28 deletions(-) create mode 100644 .clang-tidy rename .github/workflows/{format.yml => lint.yml} (58%) create mode 100644 tests/.clang-tidy diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 00000000..67934161 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,34 @@ +# Copyright 2026 The Khronos Group Inc. +# Copyright 2026 Valve Corporation +# Copyright 2026 LunarG, Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +--- +Checks: > + bugprone-*, + cert-*, + clang-analyzer-*, + concurrency-*, + misc-*, + performance-*, + portability-*, + readability-inconsistent-declaration-parameter-name, + readability-isolate-declaration, + readability-non-const-parameter, + readability-redundant-casting, + readability-redundant-declaration, + readability-redundant-parentheses, + readability-suspicious-call-argument, + -bugprone-easily-swappable-parameters, + -cert-int09-c, + -misc-include-cleaner, + -misc-use-internal-linkage, + -misc-use-anonymous-namespace, + -misc-non-private-member-variables-in-classes, + -performance-enum-size, + -portability-avoid-pragma-once +WarningsAsErrors: '*' +HeaderFilterRegex: '.*/include/.*' +ExcludeHeaderFilterRegex: 'external/.*' +FormatStyle: none diff --git a/.github/workflows/format.yml b/.github/workflows/lint.yml similarity index 58% rename from .github/workflows/format.yml rename to .github/workflows/lint.yml index eee64481..0d7f49a3 100644 --- a/.github/workflows/format.yml +++ b/.github/workflows/lint.yml @@ -3,7 +3,7 @@ # # SPDX-License-Identifier: Apache-2.0 -name: format +name: lint on: push: @@ -32,3 +32,26 @@ jobs: # turns a violation into a nonzero exit. git ls-files -z -- '*.c' '*.h' '*.cpp' '*.hpp' | xargs -0 -r clang-format --dry-run --Werror + + clang-tidy: + name: clang-tidy + runs-on: ubuntu-26.04 + timeout-minutes: 30 + + env: + CLANG_TIDY_VERSION: 22 + + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-python@v7 + with: + python-version: '3.10' + - run: | + cmake -S. -B build \ + -D CMAKE_BUILD_TYPE=Release \ + -D UPDATE_DEPS=ON \ + -D VUL_WERROR=ON \ + -D BUILD_TESTS=ON \ + -D USE_CLANG_TIDY=ON \ + -D CLANG_TIDY_EXE=$(command -v clang-tidy-${CLANG_TIDY_VERSION}) + - run: cmake --build build diff --git a/CMakeLists.txt b/CMakeLists.txt index 3ed3c345..fd5f7480 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -50,6 +50,16 @@ if (VUL_ENABLE_UBSAN) endif() endif() +option(USE_CLANG_TIDY "Run clang-tidy on the loader sources as part of the build") +if (USE_CLANG_TIDY) + if (CMAKE_VERSION VERSION_LESS "3.27") + message(FATAL_ERROR "USE_CLANG_TIDY requires CMake 3.27 or newer (for the SKIP_LINTING source property)") + endif() + find_program(CLANG_TIDY_EXE NAMES clang-tidy REQUIRED) + set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY_EXE}") + set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}") +endif() + add_subdirectory(src) add_subdirectory(include) diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp index 108f4ef2..84ce0376 100644 --- a/include/vulkan/utility/vk_small_containers.hpp +++ b/include/vulkan/utility/vk_small_containers.hpp @@ -48,11 +48,11 @@ class vector { vector(vector &&other) noexcept : size_(0), capacity_(N), working_store_(GetSmallStore()) { if (other.large_store_) { MoveLargeStore(other); + // Per the spec, when constructing from other, other is guaranteed to be empty after the constructor runs + other.clear(); } else { PushBackFrom(std::move(other)); } - // Per the spec, when constructing from other, other is guaranteed to be empty after the constructor runs - other.clear(); } explicit vector(size_type size, const value_type &value = value_type()) noexcept diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp index 70f5ddf2..4fb8fc6e 100644 --- a/include/vulkan/utility/vk_sparse_range_map.hpp +++ b/include/vulkan/utility/vk_sparse_range_map.hpp @@ -71,9 +71,7 @@ struct range { // all invalid < valid, allows map/set validity check by looking at begin()->first // all invalid are equal, thus only equal if this is invalid and rhs is valid result = rhs.valid(); - } else if (begin < rhs.begin) { - result = true; - } else if ((begin == rhs.begin) && (end < rhs.end)) { + } else if ((begin < rhs.begin) || ((begin == rhs.begin) && (end < rhs.end))) { result = true; // Simple common case -- boundary case require equality check for correctness. } return result; @@ -1604,7 +1602,7 @@ const MappedType &evaluate(const CachedLowerBound &clb, const MappedType &defaul if (clb->valid) { return clb->lower_bound->second; } - return default_value; + return default_value; // NOLINT(bugprone-return-const-ref-from-parameter) } // Split a range into pieces bound by the intersection of the iterator's range and the supplied range diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp index 69b9bd69..ce713e44 100644 --- a/src/layer/layer_settings_manager.cpp +++ b/src/layer/layer_settings_manager.cpp @@ -86,7 +86,7 @@ static std::string GetEnvironment(const char *variable) { delete[] buffer; return output; #else - const char *output = std::getenv(variable); + const char *output = std::getenv(variable); // NOLINT(concurrency-mt-unsafe) return output == nullptr ? "" : output; #endif } @@ -207,7 +207,7 @@ std::filesystem::path LayerSettings::FindSettingsFile() { if (search_path != "") { std::string home_file = search_path + "/vulkan/settings.d/vk_layer_settings.txt"; if (stat(home_file.c_str(), &info) == 0) { - if (info.st_mode & S_IFREG) { + if (S_ISREG(info.st_mode)) { return home_file; } } @@ -275,6 +275,7 @@ void LayerSettings::Log(const char *pSettingName, const char *pMessage) { this->last_log_message = pMessage; if (this->pCallback == nullptr) { + // NOLINTNEXTLINE(cert-err33-c) fprintf(stderr, "LAYER SETTING (%s) error: %s\n", this->last_log_setting.c_str(), this->last_log_message.c_str()); } else { this->pCallback(this->last_log_setting.c_str(), this->last_log_message.c_str()); diff --git a/src/layer/layer_settings_util.cpp b/src/layer/layer_settings_util.cpp index ede8b0b7..c59eb1ff 100644 --- a/src/layer/layer_settings_util.cpp +++ b/src/layer/layer_settings_util.cpp @@ -107,7 +107,8 @@ char GetEnvDelimiter() { char FindDelimiter(const std::string &s) { if (s.find(',') != std::string::npos) { return ','; - } else if (s.find(GetEnvDelimiter()) != std::string::npos) { + } + if (s.find(GetEnvDelimiter()) != std::string::npos) { return GetEnvDelimiter(); } else { return ','; @@ -214,12 +215,15 @@ VkuFrameset ToFrameSet(const std::string &s) { const std::vector &frameset_split = vl::Split(s, '-'); if (frameset_split.size() >= 1) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) frameset.first = static_cast(std::atoll(frameset_split[0].c_str())); } if (frameset_split.size() >= 2) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) frameset.count = static_cast(std::atoll(frameset_split[1].c_str())); } if (frameset_split.size() >= 3) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) frameset.step = static_cast(std::atoll(frameset_split[2].c_str())); } @@ -256,7 +260,7 @@ bool IsFloat(const std::string &s) { return std::regex_search(s, FRAME_REGEX); } -std::string FormatString(const char *message, ...) { +std::string FormatString(const char *message, ...) { // NOLINT(cert-dcl50-cpp) std::size_t const STRING_BUFFER(4096); assert(message != nullptr); @@ -266,7 +270,7 @@ std::string FormatString(const char *message, ...) { va_list list; va_start(list, message); - vsnprintf(buffer, STRING_BUFFER, message, list); + vsnprintf(buffer, STRING_BUFFER, message, list); // NOLINT(cert-err33-c) va_end(list); return buffer; diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp index 92fc8232..39f0189e 100644 --- a/src/layer/vk_layer_settings.cpp +++ b/src/layer/vk_layer_settings.cpp @@ -129,6 +129,7 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char for (std::size_t i = 0, n = values.size(); i < n; ++i) { const std::string &setting_value = vl::ToLower(settings[i]); if (vl::IsInteger(setting_value)) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion, cert-err34-c) values[i] = (std::atoi(setting_value.c_str()) != 0) ? VK_TRUE : VK_FALSE; } else if (setting_value == "true" || setting_value == "false") { values[i] = (setting_value == "true") ? VK_TRUE : VK_FALSE; @@ -178,6 +179,7 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char for (std::size_t i = 0, n = values.size(); i < n; ++i) { const std::string &setting_value = vl::ToLower(settings[i]); if (vl::IsInteger(setting_value)) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) values[i] = std::atoi(setting_value.c_str()); } else { const std::string &message = @@ -385,6 +387,7 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char for (std::size_t i = 0, n = values.size(); i < n; ++i) { const std::string &setting_value = vl::ToLower(settings[i]); if (vl::IsFloat(setting_value)) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) values[i] = static_cast(std::atof(setting_value.c_str())); } else { const std::string &message = @@ -430,6 +433,7 @@ VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char for (std::size_t i = 0, n = values.size(); i < n; ++i) { const std::string &setting_value = vl::ToLower(settings[i]); if (vl::IsFloat(setting_value)) { + // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion,cert-err34-c) values[i] = std::atof(setting_value.c_str()); } else { const std::string &message = @@ -688,6 +692,7 @@ static bool vkuHasSetting(uint32_t settingsCount, const char *const *pSettings, return false; } +// NOLINTNEXTLINE(misc-const-correctness) VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t *pUnknownSettingCount, const char **pUnknownSettings) { diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp index 162ae0a5..5662bb2d 100644 --- a/src/layer/vk_layer_settings_helper.cpp +++ b/src/layer/vk_layer_settings_helper.cpp @@ -15,7 +15,7 @@ static std::string Merge(const std::vector &strings) { for (std::size_t i = 0, n = strings.size(); i < n; ++i) { if (!result.empty()) { - result += ","; + result += ','; } result += strings[i]; } diff --git a/tests/.clang-tidy b/tests/.clang-tidy new file mode 100644 index 00000000..3d3bc4d4 --- /dev/null +++ b/tests/.clang-tidy @@ -0,0 +1,9 @@ +# Copyright 2026 The Khronos Group Inc. +# Copyright 2026 Valve Corporation +# Copyright 2026 LunarG, Inc. + +# SPDX-License-Identifier: Apache-2.0 + +--- +InheritParentConfig: true +Checks: -misc-const-correctness diff --git a/tests/small_containers.cpp b/tests/small_containers.cpp index c9ea8735..1ffa8107 100644 --- a/tests/small_containers.cpp +++ b/tests/small_containers.cpp @@ -122,7 +122,7 @@ TEST(small_vector, int_resize) { } struct NoDefaultCons { - NoDefaultCons(int x) : x(x) {} + NoDefaultCons(int x) : x(x) {} // NOLINT(misc-explicit-constructor) int x; }; @@ -296,7 +296,7 @@ TEST(small_vector, construct) { ASSERT_TRUE(HaveSameElements(ref_small, v_small_emplace)); // Copy construct from small_store - SmallVector v_small_copy(ref_small); + SmallVector v_small_copy(ref_small); // NOLINT(performance-unnecessary-copy-initialization) ASSERT_TRUE(HaveSameElements(ref_small, v_small_copy)); // Move construct from small_store @@ -315,7 +315,7 @@ TEST(small_vector, construct) { ASSERT_TRUE(HaveSameElements(ref_large, v_large_emplace)); // Copy construct from large_store - SmallVector v_large_copy(ref_large); + SmallVector v_large_copy(ref_large); // NOLINT(performance-unnecessary-copy-initialization) ASSERT_TRUE(HaveSameElements(ref_large, v_large_copy)); // Move construct from large_store @@ -396,6 +396,7 @@ TEST(small_vector, assign) { v_src = ref_large; v_dst = ref_xl; v_dst = std::move(v_src); + // NOLINTNEXTLINE(bugprone-use-after-move) ASSERT_TRUE(v_src.empty()); // Since large moves move the large store, the source is empty, but not required by spec of vector ASSERT_TRUE(HaveSameElements(ref_large, v_dst)); @@ -410,6 +411,6 @@ TEST(small_vector, assign) { v_src = ref_xxl; v_dst = ref_xl; v_dst = std::move(v_src); - ASSERT_TRUE(v_src.empty()); + ASSERT_TRUE(v_src.empty()); // NOLINT(bugprone-use-after-move) ASSERT_TRUE(HaveSameElements(ref_xxl, v_dst)); } diff --git a/tests/struct_helper.cpp b/tests/struct_helper.cpp index 8167b414..e1e7a8b9 100644 --- a/tests/struct_helper.cpp +++ b/tests/struct_helper.cpp @@ -76,7 +76,9 @@ struct SomeVkTypes { VkImageViewUsageCreateInfo t0{}; VkImageDrmFormatModifierExplicitCreateInfoEXT t1 = vku::InitStructHelper(); VkBufferCreateInfo t2 = vku::InitStruct(); + // NOLINTNEXTLINE(bugprone-throwing-static-initialization,cert-err58-cpp) inline static const auto t3 = vku::InitStruct(); + // NOLINTNEXTLINE(bugprone-throwing-static-initialization,cert-err58-cpp) inline static const VkDeviceCreateInfo t4 = vku::InitStructHelper(); }; diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp index 10199f78..d7613dba 100644 --- a/tests/test_formats.cpp +++ b/tests/test_formats.cpp @@ -482,7 +482,7 @@ TEST(format_utils, vkuFormatTexelBlockExtent) { EXPECT_EQ(extent.depth, 1u); } } - auto extent = vkuFormatTexelBlockExtent(static_cast(10001)); + auto extent = vkuFormatTexelBlockExtent(static_cast(10001)); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) EXPECT_EQ(extent.width, 0u); EXPECT_EQ(extent.height, 0u); EXPECT_EQ(extent.depth, 0u); diff --git a/tests/test_interface.cpp b/tests/test_interface.cpp index 0e96725c..06638334 100644 --- a/tests/test_interface.cpp +++ b/tests/test_interface.cpp @@ -17,7 +17,7 @@ inline VKAPI_ATTR PFN_vkVoidFunction local_vkGetInstanceProcAddr(VkInstance inst return NULL; } - if (strcmp(pName, "vkGetInstanceProcAddr")) { + if (0 == strcmp(pName, "vkGetInstanceProcAddr")) { return reinterpret_cast(&local_vkGetInstanceProcAddr); } @@ -29,7 +29,7 @@ inline VKAPI_ATTR PFN_vkVoidFunction local_vkGetDeviceProcAddr(VkDevice device, return NULL; } - if (strcmp(pName, "vkGetDeviceProcAddr")) { + if (0 == strcmp(pName, "vkGetDeviceProcAddr")) { return reinterpret_cast(&local_vkGetDeviceProcAddr); } diff --git a/tests/test_setting_cast.cpp b/tests/test_setting_cast.cpp index ddcad399..d0cb7c59 100644 --- a/tests/test_setting_cast.cpp +++ b/tests/test_setting_cast.cpp @@ -297,6 +297,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) { value_count = 0; result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr); + EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(2u, value_count); std::vector string_values(input_values.size()); diff --git a/tests/test_setting_env.cpp b/tests/test_setting_env.cpp index c8f0c391..79450e33 100644 --- a/tests/test_setting_env.cpp +++ b/tests/test_setting_env.cpp @@ -17,7 +17,7 @@ static void SetEnv(const char* value) { #ifdef _WIN32 _putenv(value); #else - putenv(const_cast(value)); + putenv(const_cast(value)); // NOLINT(concurrency-mt-unsafe,misc-include-cleaner) #endif } diff --git a/tests/vk_enum_string_helper.cpp b/tests/vk_enum_string_helper.cpp index 10a5291a..22b506b7 100644 --- a/tests/vk_enum_string_helper.cpp +++ b/tests/vk_enum_string_helper.cpp @@ -16,7 +16,7 @@ TEST(vk_enum_string_helper, string_VkResult) { auto str = string_VkResult(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -27,7 +27,7 @@ TEST(vk_enum_string_helper, string_VkStructureType) { auto str = string_VkStructureType(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -38,7 +38,7 @@ TEST(vk_enum_string_helper, string_VkPipelineCacheHeaderVersion) { auto str = string_VkPipelineCacheHeaderVersion(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -49,7 +49,7 @@ TEST(vk_enum_string_helper, string_VkImageLayout) { auto str = string_VkImageLayout(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -60,7 +60,7 @@ TEST(vk_enum_string_helper, string_VkObjectType) { auto str = string_VkObjectType(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -71,7 +71,7 @@ TEST(vk_enum_string_helper, string_VkFormat) { auto str = string_VkFormat(val); - EXPECT_STREQ(magic_str.data(), str); + EXPECT_STREQ(magic_str.data(), str); // NOLINT(bugprone-suspicious-stringview-data-usage) } } @@ -100,4 +100,4 @@ TEST(vk_enum_string_helper, string_FlagBits_multi_bit) { EXPECT_EQ(string_VkShaderStageFlags(VK_SHADER_STAGE_ALL_GRAPHICS), "VK_SHADER_STAGE_ALL_GRAPHICS"); EXPECT_EQ(string_VkShaderStageFlags(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT), "VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT"); -} \ No newline at end of file +} From 43ae331d92e728e7a8f1b9b33ed18d7fa2b7ec2c Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Mon, 5 Oct 2026 16:54:12 -0500 Subject: [PATCH 13/13] safe: Fixup VkClusterAccelerationStructureOpInputNV codegen VkClusterAccelerationStructureOpInputNV is a union of pointers, and the safe struct has special functionality for handling unions of pointers. --- include/vulkan/utility/vk_safe_struct.hpp | 20 +---- scripts/generators/safe_struct_generator.py | 2 + src/vulkan/vk_safe_struct_vendor.cpp | 85 ++------------------- 3 files changed, 10 insertions(+), 97 deletions(-) diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 980231d1..d80f447c 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -23393,24 +23393,6 @@ struct safe_VkClusterAccelerationStructureMoveObjectsInputNV { return reinterpret_cast(this); } }; -union safe_VkClusterAccelerationStructureOpInputNV { - safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel; - safe_VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters; - safe_VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects; - - safe_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV* in_struct, - PNextCopyState* copy_state = {}); - safe_VkClusterAccelerationStructureOpInputNV(const safe_VkClusterAccelerationStructureOpInputNV& copy_src); - safe_VkClusterAccelerationStructureOpInputNV& operator=(const safe_VkClusterAccelerationStructureOpInputNV& copy_src); - safe_VkClusterAccelerationStructureOpInputNV(); - ~safe_VkClusterAccelerationStructureOpInputNV(); - void initialize(const VkClusterAccelerationStructureOpInputNV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkClusterAccelerationStructureOpInputNV* copy_src, PNextCopyState* copy_state = {}); - VkClusterAccelerationStructureOpInputNV* ptr() { return reinterpret_cast(this); } - VkClusterAccelerationStructureOpInputNV const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkClusterAccelerationStructureInputInfoNV { VkStructureType sType; void* pNext{}; @@ -23418,7 +23400,7 @@ struct safe_VkClusterAccelerationStructureInputInfoNV { VkBuildAccelerationStructureFlagsKHR flags; VkClusterAccelerationStructureOpTypeNV opType; VkClusterAccelerationStructureOpModeNV opMode; - safe_VkClusterAccelerationStructureOpInputNV opInput; + VkClusterAccelerationStructureOpInputNV opInput; safe_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py index 5f531595..6bd3e90f 100644 --- a/scripts/generators/safe_struct_generator.py +++ b/scripts/generators/safe_struct_generator.py @@ -60,10 +60,12 @@ def __init__(self): 'VkIndirectCommandsTokenDataEXT', 'VkIndirectExecutionSetInfoEXT', 'VkResourceDescriptorDataEXT', + 'VkClusterAccelerationStructureOpInputNV', ] self.union_of_pointer_callers = [ 'VkDescriptorGetInfoEXT', 'VkResourceDescriptorInfoEXT', + 'VkClusterAccelerationStructureMoveObjectsInputNV', ] # Will update the the function interface diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp index 7ce03e92..97ab6002 100644 --- a/src/vulkan/vk_safe_struct_vendor.cpp +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -22611,78 +22611,6 @@ void safe_VkClusterAccelerationStructureMoveObjectsInputNV::initialize( pNext = SafePnextCopy(copy_src->pNext); } -safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV( - const VkClusterAccelerationStructureOpInputNV* in_struct, PNextCopyState*) { - initialize(in_struct); -} - -safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV() : pClustersBottomLevel(nullptr) {} - -safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV( - const safe_VkClusterAccelerationStructureOpInputNV& copy_src) { - pClustersBottomLevel = nullptr; - pTriangleClusters = nullptr; - pMoveObjects = nullptr; - if (copy_src.pClustersBottomLevel) - pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src.pClustersBottomLevel); - if (copy_src.pTriangleClusters) - pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src.pTriangleClusters); - if (copy_src.pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src.pMoveObjects); -} - -safe_VkClusterAccelerationStructureOpInputNV& safe_VkClusterAccelerationStructureOpInputNV::operator=( - const safe_VkClusterAccelerationStructureOpInputNV& copy_src) { - if (©_src == this) return *this; - - if (pClustersBottomLevel) delete pClustersBottomLevel; - if (pTriangleClusters) delete pTriangleClusters; - if (pMoveObjects) delete pMoveObjects; - - pClustersBottomLevel = nullptr; - pTriangleClusters = nullptr; - pMoveObjects = nullptr; - if (copy_src.pClustersBottomLevel) - pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src.pClustersBottomLevel); - if (copy_src.pTriangleClusters) - pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src.pTriangleClusters); - if (copy_src.pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src.pMoveObjects); - - return *this; -} - -safe_VkClusterAccelerationStructureOpInputNV::~safe_VkClusterAccelerationStructureOpInputNV() { - if (pClustersBottomLevel) delete pClustersBottomLevel; - if (pTriangleClusters) delete pTriangleClusters; - if (pMoveObjects) delete pMoveObjects; -} - -void safe_VkClusterAccelerationStructureOpInputNV::initialize(const VkClusterAccelerationStructureOpInputNV* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pClustersBottomLevel) delete pClustersBottomLevel; - if (pTriangleClusters) delete pTriangleClusters; - if (pMoveObjects) delete pMoveObjects; - pClustersBottomLevel = nullptr; - pTriangleClusters = nullptr; - pMoveObjects = nullptr; - if (in_struct->pClustersBottomLevel) - pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(in_struct->pClustersBottomLevel); - if (in_struct->pTriangleClusters) - pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(in_struct->pTriangleClusters); - if (in_struct->pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(in_struct->pMoveObjects); -} - -void safe_VkClusterAccelerationStructureOpInputNV::initialize(const safe_VkClusterAccelerationStructureOpInputNV* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - pClustersBottomLevel = nullptr; - pTriangleClusters = nullptr; - pMoveObjects = nullptr; - if (copy_src->pClustersBottomLevel) - pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src->pClustersBottomLevel); - if (copy_src->pTriangleClusters) - pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src->pTriangleClusters); - if (copy_src->pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src->pMoveObjects); -} - safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStructureInputInfoNV( const VkClusterAccelerationStructureInputInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), @@ -22690,7 +22618,7 @@ safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStruct flags(in_struct->flags), opType(in_struct->opType), opMode(in_struct->opMode), - opInput(&in_struct->opInput) { + opInput(in_struct->opInput) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } @@ -22702,7 +22630,8 @@ safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStruct maxAccelerationStructureCount(), flags(), opType(), - opMode() {} + opMode(), + opInput() {} safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStructureInputInfoNV( const safe_VkClusterAccelerationStructureInputInfoNV& copy_src) { @@ -22711,7 +22640,7 @@ safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStruct flags = copy_src.flags; opType = copy_src.opType; opMode = copy_src.opMode; - opInput.initialize(©_src.opInput); + opInput = copy_src.opInput; pNext = SafePnextCopy(copy_src.pNext); } @@ -22726,7 +22655,7 @@ safe_VkClusterAccelerationStructureInputInfoNV& safe_VkClusterAccelerationStruct flags = copy_src.flags; opType = copy_src.opType; opMode = copy_src.opMode; - opInput.initialize(©_src.opInput); + opInput = copy_src.opInput; pNext = SafePnextCopy(copy_src.pNext); return *this; @@ -22742,7 +22671,7 @@ void safe_VkClusterAccelerationStructureInputInfoNV::initialize(const VkClusterA flags = in_struct->flags; opType = in_struct->opType; opMode = in_struct->opMode; - opInput.initialize(&in_struct->opInput); + opInput = in_struct->opInput; pNext = SafePnextCopy(in_struct->pNext, copy_state); } @@ -22753,7 +22682,7 @@ void safe_VkClusterAccelerationStructureInputInfoNV::initialize(const safe_VkClu flags = copy_src->flags; opType = copy_src->opType; opMode = copy_src->opMode; - opInput.initialize(©_src->opInput); + opInput = copy_src->opInput; pNext = SafePnextCopy(copy_src->pNext); }