GitLab

The function has dropped the onerous use of a tuple in favour of using
output parameters.

The previous changes of all types being listed now also means that types
can always be fully checked for existance rather than just returning
success on non-found types.

As has happened with the VkPipelineDepthStencilStateCreateFlagBits type,
enum sets that were once empty may change in the future, and at that
point not have a zero-value.

This breaks backward compatability, and so a new field has been added
that allows for empty fields/values if the type was once empty.

The ability to convert a VkResult to a readable string is too useful to
keep locked away just inside the std::error_code.

As such, that functionality has been shifted to a separate header that
provides just the vkResultToString(VkResult) function standalone, and
now also be C-compatible.

As extensions mature over time, the same value can be associated with
multiple names, perhaps originally as an 'EXT' then a 'KHR' extension.

To provide back the most accurate text for corresponding VkResult error
code values, the checking of codes introduced in later Vulkan versions
has been shifted to be first, and comparisons to be in descending order
that they appeared.

Better compatability with unused but named parameters.

A number of the cleanup functions have no members that need to be
cleaned. As such, the parameters are unused and thus cause warnings when
compiled with high-enough warning levels.

Removing unused parameters makes improves the usability of the header.

Uses RenderPassCreate flag bits modified in v134.

The chosen Huawei enum value was only available in a later extension, so
swapped out for a value available with the original.

Structs are now in the order they originally appeared in the Vulkan
specification.

When generating error codes, it will now output them in the order in
which the values were added to the specification.

Due to the Vulkan XML being parsed newest to oldest, enum values that
were reserved with that keyword in the name would be parsed after the
replacement value and name, and thus be generated after in the enum set
lists.

This meant that when serializing, the 'RESERVED' version would almost
always be used instead of the replacement name. This was because the
serialization function would go in reverse order in attempts to use
larger combination values typically later in the enum list.

To try to use the 'proper' names instead when they are available, when
generating the header, if will now iterate through the available
versions and write out only the enums that appeared in that version.
This would lead to items added to the spec after to appear after, and
thus be used for serialization instead.

Some enums can get added or modified in other later extensions and in
such cases would inherit the incorrect extension  number.

To fix, it now checks the enum for any speific 'extnumber' attribute and
will use that if it exists instead for the correct value.

The VkAccessFlagBits2KHR type that is one of the only two 64-bit flag
types was added only recently, and as such not all platforms have it
available.

As such, the serialization64 tests are now guarded via the
VK_KHR_synchronization2 define, which the flag types are part of.

In cases where there are no initial values for an enum, but a feature or
extension extends it anyways, it would fail to find the enum node and
crash with a None element.

Move the blurb about the default 72 starting value, and behaviour when
the tag is below the set value to continue instead of break.

The -a option is no longer used.

There are two VkFlags64 types in Vulkan that must be handled,
VkPipelineStageFlags2KHR and VkAccessFlags2KHR. To facilitate this, some
64-bit functions have been added, and all the older 32-bit based
functions coverted to 64-bit, and the 32 bit public functions delegate
to these.

Need to test the C headers both in a C and C++ compilation environment.

Updated cleanup header for C++ support by adding an explicit C-style
cast in the cleanup_vk_struct function.

Checks that the current Vulkan header on the system is supported.

When including the C header in a CPP environment, GCC could not figure
out _Static_assert and failed to compile it.

So both static asserts are used, based on the compiling environment.

Properly goes through individual letters and passes those suffixes
through.

Items would be double-cleaned up, even if the first layer was an array
of pointers to the actual data.

Properly iterates through nested pointers that point to arrays.

Checks for nullptr's for standalone pointer objects.

Can't cleanup what doesn't exist.