cdgiessen / vk-module Goto Github PK

This way you don't have to specify an argument manually.
QueueSubmit() requires a Fence() to be provided currently, which is cumbersome.
Making it a pointer would allow actual nullptr values, but it may be simpler to have Fence fence = Fence() so the .get() function doesn't have to be conditional.

Note, there must be logic to guarantee the = default() only occurs if its the last argument in a function. Allocator Callbacks are in the middle, thus can't be defaulted.

vkCreateGraphicsPipelines and vkCreateComputePipelines take an array of pipeline create info's and should return a vector of pipelines. This is the last create/query function category but needs special consideration wrt how the len attributes are handled.

operator+ is terse but really confusing. static_cast<C_enum>(C++_enum) is too verbose.

The ability to print vk::Result is the most useful to_string function, it only makes sense to include it in the main headers and not be separate.
Only difficulty is that now it must be documented that the vk::Result to string is inside the main header.

C++20 module shouldn't have such a reason to split them in the first place.

Currently, structs & unions do not properly guard against the vulkan headers not containing newer extensions.

For example, PhysicalDevice4444FormatsFeaturesEXT will fail to compile if the header version isn't new enough to contain it.

Create a library that implements all C api entry points, allow mocking of an application without needing a vulkan driver or loader.

Needs to allow specifying the return values of Vulkan functions.

Also might make more sense to be in a separate repository.

Similar to Mock-ICD but before the loader, not after.

Extension functions which are aliases to now core functions do not have the alias version present.
This is a tricky issue, as the internal function in the loader may not be distinct (todo: double check that).

For example vkGetPhysicalDeviceImageFormatProperties2KHR doesn't exist, only vkGetPhysicalDeviceImageFormatProperties2. If the KHR version was added what should happen if the KHR version is called on a 1.0 driver that doesn't support the extension?

It would be really nice if the bindings did the necessary grunt work to disable asan checking inside the drivers, eliminating any driver or layer related false positives from application output.

Requires using the Mock Vulkan API library.
Will make tests run every time, ensuring changes don't break code.

Currently, DeviceFunctions only loads the function pointers but doesn't store the Device handle, so no device functions will succeed.

There are many capabilities that would be very convenient. conversion to bool, allowing to be ignored (by an explicit function call that does nothing, for use in functions which [[nodiscard]], and more flexibility for interaction with the expected type.

Only downside would be that the enum values would have to be made class constants to preserve the current syntax. vk::Result::Success and vk::Result::EventSet` would need to continue to work.

Create structs to hold all intermediate data and have .setXXX() member functions.
Anything that is passed by counter+pointer pairs will have a vector to store the data.
Return type is an expected like type, eg expected<NewValue, Error>.

Need to decide how to handle functions which can create multiple objects, and functions which aren't 'creation' but allocation (descriptor sets & command buffers).

Vulkan.h has macro defines to specify the major, minor, and patch version of the headers.
The bindings need to have similar functionality.

Also, the VK_MAKE_VERSION() macro needs to be made accessible.

Make overloads for any function which takes count+pointer argument pairs into functions with std::span. This allows for easy interoperation with std::vector & std::array.

DeviceFunctions take device & InstanceFunctions to construct, this make the InstanceFunctions inconsistent (which takes the loader, not global functions)

It would be nice to see the debug utils handle in the debugger.
This could be accomplished by creating a hash map that the debug utils calls know about and modify.
Then natvis can call into that with the handle, then get the string from the hash map, and thus you get nice strings to go with your uint64_t values.

Low priority, but would be really cool!

Cleaner and less "what does 'true'/'false' mean.

EnumerateInstanceExtensionProperties
EnumerateInstanceLayerProperties
EnumerateInstanceVersion
pfn_EnumeratePhysicalDevices
pfn_EnumerateDeviceExtensionProperties
pfn_EnumeratePhysicalDeviceGroups
pfn_EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR

Do not do EnumerateInstanceDeviceProperties - deprecated

Current CMakeLists.txt is geared to work on my system and my system only.
It should be rewritten so optional parts (like generation python script) properly check for python or download the other dependencies as necessary.
It should also be tested against using system vulkan-headers, and getting the vk.xml from the SDK/packages/manually downloaded headers.

Autogenerating hundreds of comparisons is a bit silly.
Also do this for union comparisons.

Reason are:
Allows C++17 users to use span - unify interface - really the only reason to do it. Having this be different between the two is silly.
span can be 'customized' to be better suited for vulkan, eg uint32_t size in most places. Make it a template argument which defaults to uint32_t.
Make an implicit conversion operator from std::span in C++20 mode for seamless interop.

Downsides:
Need to have vk::Span be as fleshed out as is reasonably possible. It can't have major deficiencies compared to std::span, lest it be a worse replacement.
More code = more tests needed

It would be nice if users could specify a custom allocator to use for the various query functions.

Currently, there are C++17 headers but no module.

The interim step is to create C++20 headers for feature testing (std::span, default operator==).

This will require build system support to make it usable for many projects.

The project requires the vk.xml and nothing else from the Vulkan-Headers repo.
It speeds up build time of the repo if the entire vulkan-headers repo isn't downloaded.

move assignment operator should return *this;