diff options
Diffstat (limited to 'examples/sybok.hpp')
| -rw-r--r-- | examples/sybok.hpp | 3881 |
1 files changed, 1911 insertions, 1970 deletions
diff --git a/examples/sybok.hpp b/examples/sybok.hpp index 8985547..05b2c3d 100644 --- a/examples/sybok.hpp +++ b/examples/sybok.hpp @@ -66,13 +66,13 @@ #define VK_NO_PROTOTYPES // On 64-bit platforms, all handles are "dispatchable" pointers -#if defined(__LP64__) || defined(_WIN64) || \ - (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \ - defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || \ - defined(__powerpc64__) +#if defined(__LP64__) || defined(_WIN64) || \ + (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \ + defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || \ + defined(__powerpc64__) -# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \ - typedef struct object##_T* object; +# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \ + typedef struct object##_T* object; // On 32-bit platforms, some "non-dispatchable" handles are 64 bit integers #else @@ -80,14 +80,14 @@ /// Trivial wrapper class for a 64-bit integer handle for type safety template<class Tag> struct NonDispatchableHandle { - explicit operator uint64_t() const noexcept { return handle; } - explicit operator bool() const noexcept { return handle; } + explicit operator uint64_t() const noexcept { return handle; } + explicit operator bool() const noexcept { return handle; } - uint64_t handle; + uint64_t handle; }; -# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \ - using object = NonDispatchableHandle<struct Sk##object##Tag>; +# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \ + using object = NonDispatchableHandle<struct Sk##object##Tag>; #endif @@ -101,11 +101,11 @@ struct NonDispatchableHandle { #include <utility> #if __cplusplus >= 201703L -# define SYBOK_NODISCARD [[nodiscard]] +# define SYBOK_NODISCARD [[nodiscard]] #elif defined(__GNUC__) -# define SYBOK_NODISCARD [[gnu::warn_unused_result]] +# define SYBOK_NODISCARD [[gnu::warn_unused_result]] #else -# define SYBOK_NODISCARD +# define SYBOK_NODISCARD #endif /// Helper macro to make array arguments format nicely @@ -119,295 +119,294 @@ class RenderCommandScope; static inline const char* string(const VkResult result) { - switch (result) { - case VK_SUCCESS: - return "Success"; - case VK_NOT_READY: - return "Not Ready"; - case VK_TIMEOUT: - return "Timeout"; - case VK_EVENT_SET: - return "Event set"; - case VK_EVENT_RESET: - return "Event reset"; - case VK_INCOMPLETE: - return "Incomplete"; - case VK_ERROR_OUT_OF_HOST_MEMORY: - return "Out of host memory"; - case VK_ERROR_OUT_OF_DEVICE_MEMORY: - return "Out of device memory"; - case VK_ERROR_INITIALIZATION_FAILED: - return "Initialization failed"; - case VK_ERROR_DEVICE_LOST: - return "Device lost"; - case VK_ERROR_MEMORY_MAP_FAILED: - return "Memory map failed"; - case VK_ERROR_LAYER_NOT_PRESENT: - return "Layer not present"; - case VK_ERROR_EXTENSION_NOT_PRESENT: - return "Extension not present"; - case VK_ERROR_FEATURE_NOT_PRESENT: - return "Feature not present"; - case VK_ERROR_INCOMPATIBLE_DRIVER: - return "Incompatible driver"; - case VK_ERROR_TOO_MANY_OBJECTS: - return "Too many objects"; - case VK_ERROR_FORMAT_NOT_SUPPORTED: - return "Format not supported"; - case VK_ERROR_FRAGMENTED_POOL: - return "Fragmented pool"; - case VK_ERROR_OUT_OF_POOL_MEMORY: // Vulkan 1.1 - return "Out of pool memory"; - case VK_ERROR_INVALID_EXTERNAL_HANDLE: // Vulkan 1.1 - return "Invalid external handle"; - case VK_ERROR_SURFACE_LOST_KHR: // VK_KHR_surface - return "Surface lost"; - case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: // VK_KHR_surface - return "Native window in use"; - case VK_SUBOPTIMAL_KHR: // VK_KHR_swapchain - return "Suboptimal"; - case VK_ERROR_OUT_OF_DATE_KHR: // VK_KHR_swapchain - return "Out of date"; - case VK_ERROR_VALIDATION_FAILED_EXT: // VK_EXT_debug_report - return "Validation failed"; - default: - break; - } - - return "Unknown error"; + switch (result) { + case VK_SUCCESS: + return "Success"; + case VK_NOT_READY: + return "Not Ready"; + case VK_TIMEOUT: + return "Timeout"; + case VK_EVENT_SET: + return "Event set"; + case VK_EVENT_RESET: + return "Event reset"; + case VK_INCOMPLETE: + return "Incomplete"; + case VK_ERROR_OUT_OF_HOST_MEMORY: + return "Out of host memory"; + case VK_ERROR_OUT_OF_DEVICE_MEMORY: + return "Out of device memory"; + case VK_ERROR_INITIALIZATION_FAILED: + return "Initialization failed"; + case VK_ERROR_DEVICE_LOST: + return "Device lost"; + case VK_ERROR_MEMORY_MAP_FAILED: + return "Memory map failed"; + case VK_ERROR_LAYER_NOT_PRESENT: + return "Layer not present"; + case VK_ERROR_EXTENSION_NOT_PRESENT: + return "Extension not present"; + case VK_ERROR_FEATURE_NOT_PRESENT: + return "Feature not present"; + case VK_ERROR_INCOMPATIBLE_DRIVER: + return "Incompatible driver"; + case VK_ERROR_TOO_MANY_OBJECTS: + return "Too many objects"; + case VK_ERROR_FORMAT_NOT_SUPPORTED: + return "Format not supported"; + case VK_ERROR_FRAGMENTED_POOL: + return "Fragmented pool"; + case VK_ERROR_OUT_OF_POOL_MEMORY: // Vulkan 1.1 + return "Out of pool memory"; + case VK_ERROR_INVALID_EXTERNAL_HANDLE: // Vulkan 1.1 + return "Invalid external handle"; + case VK_ERROR_SURFACE_LOST_KHR: // VK_KHR_surface + return "Surface lost"; + case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: // VK_KHR_surface + return "Native window in use"; + case VK_SUBOPTIMAL_KHR: // VK_KHR_swapchain + return "Suboptimal"; + case VK_ERROR_OUT_OF_DATE_KHR: // VK_KHR_swapchain + return "Out of date"; + case VK_ERROR_VALIDATION_FAILED_EXT: // VK_EXT_debug_report + return "Validation failed"; + default: + break; + } + + return "Unknown error"; } static inline const char* string(const VkPresentModeKHR presentMode) { - switch (presentMode) { - case VK_PRESENT_MODE_IMMEDIATE_KHR: - return "Immediate"; - case VK_PRESENT_MODE_MAILBOX_KHR: - return "Mailbox"; - case VK_PRESENT_MODE_FIFO_KHR: - return "FIFO"; - case VK_PRESENT_MODE_FIFO_RELAXED_KHR: - return "Relaxed FIFO"; - default: - break; - } - - return "Unknown present mode"; + switch (presentMode) { + case VK_PRESENT_MODE_IMMEDIATE_KHR: + return "Immediate"; + case VK_PRESENT_MODE_MAILBOX_KHR: + return "Mailbox"; + case VK_PRESENT_MODE_FIFO_KHR: + return "FIFO"; + case VK_PRESENT_MODE_FIFO_RELAXED_KHR: + return "Relaxed FIFO"; + default: + break; + } + + return "Unknown present mode"; } static inline const char* string(const VkDebugReportFlagBitsEXT flag) { - switch (flag) { - case VK_DEBUG_REPORT_INFORMATION_BIT_EXT: - return "Information"; - case VK_DEBUG_REPORT_WARNING_BIT_EXT: - return "Warning"; - case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: - return "Performance Warning"; - case VK_DEBUG_REPORT_ERROR_BIT_EXT: - return "Error"; - case VK_DEBUG_REPORT_DEBUG_BIT_EXT: - return "Debug"; - default: - break; - } - - return "Unknown report"; + switch (flag) { + case VK_DEBUG_REPORT_INFORMATION_BIT_EXT: + return "Information"; + case VK_DEBUG_REPORT_WARNING_BIT_EXT: + return "Warning"; + case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: + return "Performance Warning"; + case VK_DEBUG_REPORT_ERROR_BIT_EXT: + return "Error"; + case VK_DEBUG_REPORT_DEBUG_BIT_EXT: + return "Debug"; + default: + break; + } + + return "Unknown report"; } template<class T> class GlobalDeleter { public: - using DestroyFunc = void (*)(T, const VkAllocationCallbacks*); + using DestroyFunc = void (*)(T, const VkAllocationCallbacks*); - GlobalDeleter() = default; - ~GlobalDeleter() = default; + GlobalDeleter() = default; + ~GlobalDeleter() = default; - GlobalDeleter(DestroyFunc destroyFunc) noexcept - : _destroyFunc{destroyFunc} - {} + GlobalDeleter(DestroyFunc destroyFunc) noexcept + : _destroyFunc{destroyFunc} + {} - GlobalDeleter(const GlobalDeleter&) = delete; - GlobalDeleter& operator=(const GlobalDeleter&) = delete; + GlobalDeleter(const GlobalDeleter&) = delete; + GlobalDeleter& operator=(const GlobalDeleter&) = delete; - GlobalDeleter(GlobalDeleter&& other) noexcept - { - std::swap(_destroyFunc, other._destroyFunc); - } + GlobalDeleter(GlobalDeleter&& other) noexcept + { + std::swap(_destroyFunc, other._destroyFunc); + } - GlobalDeleter& operator=(GlobalDeleter&& other) noexcept - { - std::swap(_destroyFunc, other._destroyFunc); - return *this; - } + GlobalDeleter& operator=(GlobalDeleter&& other) noexcept + { + std::swap(_destroyFunc, other._destroyFunc); + return *this; + } - void operator()(T handle) noexcept - { - if (_destroyFunc && handle) { - _destroyFunc(handle, nullptr); - } - } + void operator()(T handle) noexcept + { + if (_destroyFunc && handle) { + _destroyFunc(handle, nullptr); + } + } private: - DestroyFunc _destroyFunc{}; + DestroyFunc _destroyFunc{}; }; template<class T, class Parent> class DependantDeleter { public: - using DestroyFunc = void (*)(Parent, T, const VkAllocationCallbacks*); + using DestroyFunc = void (*)(Parent, T, const VkAllocationCallbacks*); - DependantDeleter() = default; - ~DependantDeleter() = default; + DependantDeleter() = default; + ~DependantDeleter() = default; - DependantDeleter(Parent parent, DestroyFunc destroyFunc) noexcept - : _parent{parent} - , _destroyFunc{destroyFunc} - {} + DependantDeleter(Parent parent, DestroyFunc destroyFunc) noexcept + : _parent{parent} + , _destroyFunc{destroyFunc} + {} - DependantDeleter(const DependantDeleter&) = delete; - DependantDeleter& operator=(const DependantDeleter&) = delete; + DependantDeleter(const DependantDeleter&) = delete; + DependantDeleter& operator=(const DependantDeleter&) = delete; - DependantDeleter(DependantDeleter&& other) noexcept { swap(other); } + DependantDeleter(DependantDeleter&& other) noexcept { swap(other); } - DependantDeleter& operator=(DependantDeleter&& other) noexcept - { - swap(other); - return *this; - } + DependantDeleter& operator=(DependantDeleter&& other) noexcept + { + swap(other); + return *this; + } - void operator()(T handle) noexcept - { - if (_parent && _destroyFunc && handle) { - _destroyFunc(_parent, handle, nullptr); - } - } + void operator()(T handle) noexcept + { + if (_parent && _destroyFunc && handle) { + _destroyFunc(_parent, handle, nullptr); + } + } private: - void swap(DependantDeleter& other) noexcept - { - std::swap(_parent, other._parent); - std::swap(_destroyFunc, other._destroyFunc); - } - - Parent _parent{}; - DestroyFunc _destroyFunc{}; + void swap(DependantDeleter& other) noexcept + { + std::swap(_parent, other._parent); + std::swap(_destroyFunc, other._destroyFunc); + } + + Parent _parent{}; + DestroyFunc _destroyFunc{}; }; template<class T, class Pool, class FreeFuncResult> class PoolDeleter { public: - using FreeFunc = FreeFuncResult (*)(VkDevice, Pool, uint32_t, const T*); - - PoolDeleter() noexcept = default; - ~PoolDeleter() noexcept = default; - - PoolDeleter(VkDevice device, - Pool pool, - uint32_t count, - FreeFunc freeFunc) noexcept - : _device{device} - , _pool{pool} - , _count{count} - , _freeFunc{freeFunc} - {} - - PoolDeleter(const PoolDeleter&) = delete; - PoolDeleter& operator=(const PoolDeleter&) = delete; - - PoolDeleter(PoolDeleter&& other) noexcept { swap(other); } - - PoolDeleter& operator=(PoolDeleter&& other) noexcept - { - swap(other); - return *this; - } - - void operator()(T* handle) noexcept - { - if (_device && _pool && handle) { - _freeFunc(_device, _pool, _count, handle); - } - } + using FreeFunc = FreeFuncResult (*)(VkDevice, Pool, uint32_t, const T*); + + PoolDeleter() noexcept = default; + ~PoolDeleter() noexcept = default; + + PoolDeleter(VkDevice device, + Pool pool, + uint32_t count, + FreeFunc freeFunc) noexcept + : _device{device} + , _pool{pool} + , _count{count} + , _freeFunc{freeFunc} + {} + + PoolDeleter(const PoolDeleter&) = delete; + PoolDeleter& operator=(const PoolDeleter&) = delete; + + PoolDeleter(PoolDeleter&& other) noexcept { swap(other); } + + PoolDeleter& operator=(PoolDeleter&& other) noexcept + { + swap(other); + return *this; + } + + void operator()(T* handle) noexcept + { + if (_device && _pool && handle) { + _freeFunc(_device, _pool, _count, handle); + } + } private: - void swap(PoolDeleter& other) noexcept - { - std::swap(_device, other._device); - std::swap(_pool, other._pool); - std::swap(_count, other._count); - std::swap(_freeFunc, other._freeFunc); - } - - VkDevice _device{}; - Pool _pool{}; - uint32_t _count{}; - FreeFunc _freeFunc{}; + void swap(PoolDeleter& other) noexcept + { + std::swap(_device, other._device); + std::swap(_pool, other._pool); + std::swap(_count, other._count); + std::swap(_freeFunc, other._freeFunc); + } + + VkDevice _device{}; + Pool _pool{}; + uint32_t _count{}; + FreeFunc _freeFunc{}; }; template<class T, class TDeleter> class UniqueDispatchableHandle { public: - using Deleter = TDeleter; - using Handle = T; + using Deleter = TDeleter; + using Handle = T; - static_assert(std::is_pointer<T>::value, ""); + static_assert(std::is_pointer<T>::value, ""); - UniqueDispatchableHandle() = default; + UniqueDispatchableHandle() = default; - UniqueDispatchableHandle(Handle handle, Deleter deleter) noexcept - : _handle{handle} - , _deleter{std::move(deleter)} - {} + UniqueDispatchableHandle(Handle handle, Deleter deleter) noexcept + : _handle{handle} + , _deleter{std::move(deleter)} + {} - ~UniqueDispatchableHandle() noexcept - { - if (_handle) { - _deleter(_handle); - } - } + ~UniqueDispatchableHandle() noexcept + { + if (_handle) { + _deleter(_handle); + } + } - UniqueDispatchableHandle(const UniqueDispatchableHandle&) noexcept = delete; - UniqueDispatchableHandle& - operator=(const UniqueDispatchableHandle&) noexcept = delete; + UniqueDispatchableHandle(const UniqueDispatchableHandle&) noexcept = delete; + UniqueDispatchableHandle& operator =( + const UniqueDispatchableHandle&) noexcept = delete; - UniqueDispatchableHandle(UniqueDispatchableHandle&& other) noexcept - { - swap(other); - } + UniqueDispatchableHandle(UniqueDispatchableHandle&& other) noexcept + { + swap(other); + } - UniqueDispatchableHandle& - operator=(UniqueDispatchableHandle&& other) noexcept - { - swap(other); - return *this; - } + UniqueDispatchableHandle& operator=(UniqueDispatchableHandle&& other) noexcept + { + swap(other); + return *this; + } - const Handle& get() const noexcept { return _handle; } + const Handle& get() const noexcept { return _handle; } - operator Handle() const noexcept { return _handle; } + operator Handle() const noexcept { return _handle; } private: - void swap(UniqueDispatchableHandle& other) noexcept - { - std::swap(_handle, other._handle); - std::swap(_deleter, other._deleter); - } - - Handle _handle{}; - Deleter _deleter{}; + void swap(UniqueDispatchableHandle& other) noexcept + { + std::swap(_handle, other._handle); + std::swap(_deleter, other._deleter); + } + + Handle _handle{}; + Deleter _deleter{}; }; -#if defined(__LP64__) || defined(_WIN64) || \ - (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \ - defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || \ - defined(__powerpc64__) +#if defined(__LP64__) || defined(_WIN64) || \ + (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \ + defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || \ + defined(__powerpc64__) template<class T, class TDeleter> using UniqueNonDispatchableHandle = UniqueDispatchableHandle<T, TDeleter>; @@ -418,55 +417,55 @@ template<class T, class TDeleter> class UniqueNonDispatchableHandle { public: - using Deleter = TDeleter; - using Handle = T; - - UniqueNonDispatchableHandle() = default; - - UniqueNonDispatchableHandle(T handle, Deleter deleter) noexcept - : _handle{handle} - , _deleter{std::move(deleter)} - { - assert(handle); - } - - ~UniqueNonDispatchableHandle() noexcept - { - if (_handle) { - _deleter(_handle); - } - } - - UniqueNonDispatchableHandle(const UniqueNonDispatchableHandle&) noexcept = - delete; - UniqueNonDispatchableHandle& - operator=(const UniqueNonDispatchableHandle&) noexcept = delete; - - UniqueNonDispatchableHandle(UniqueNonDispatchableHandle&& other) noexcept - { - swap(other); - } - - UniqueNonDispatchableHandle& - operator=(UniqueNonDispatchableHandle&& other) noexcept - { - swap(other); - return *this; - } - - const Handle& get() const noexcept { return _handle; } - - operator Handle() const noexcept { return _handle; } + using Deleter = TDeleter; + using Handle = T; + + UniqueNonDispatchableHandle() = default; + + UniqueNonDispatchableHandle(T handle, Deleter deleter) noexcept + : _handle{handle} + , _deleter{std::move(deleter)} + { + assert(handle); + } + + ~UniqueNonDispatchableHandle() noexcept + { + if (_handle) { + _deleter(_handle); + } + } + + UniqueNonDispatchableHandle(const UniqueNonDispatchableHandle&) noexcept = + delete; + UniqueNonDispatchableHandle& operator =( + const UniqueNonDispatchableHandle&) noexcept = delete; + + UniqueNonDispatchableHandle(UniqueNonDispatchableHandle&& other) noexcept + { + swap(other); + } + + UniqueNonDispatchableHandle& operator=( + UniqueNonDispatchableHandle&& other) noexcept + { + swap(other); + return *this; + } + + const Handle& get() const noexcept { return _handle; } + + operator Handle() const noexcept { return _handle; } private: - void swap(UniqueNonDispatchableHandle& other) noexcept - { - std::swap(_handle, other._handle); - std::swap(_deleter, other._deleter); - } - - T _handle{}; - Deleter _deleter{}; + void swap(UniqueNonDispatchableHandle& other) noexcept + { + std::swap(_handle, other._handle); + std::swap(_deleter, other._deleter); + } + + T _handle{}; + Deleter _deleter{}; }; #endif @@ -475,83 +474,83 @@ template<class Vector, class Deleter> class UniqueArrayHandle { public: - using T = typename Vector::value_type; + using T = typename Vector::value_type; - UniqueArrayHandle() = default; + UniqueArrayHandle() = default; - UniqueArrayHandle(uint32_t size, Vector&& array, Deleter deleter) noexcept - : _array{std::move(array)} - , _deleter{std::move(deleter)} - , _size{size} - { - assert(!_array.empty()); - } + UniqueArrayHandle(uint32_t size, Vector&& array, Deleter deleter) noexcept + : _array{std::move(array)} + , _deleter{std::move(deleter)} + , _size{size} + { + assert(!_array.empty()); + } - ~UniqueArrayHandle() noexcept - { - if (!_array.empty()) { - _deleter(_array.data()); - } - } + ~UniqueArrayHandle() noexcept + { + if (!_array.empty()) { + _deleter(_array.data()); + } + } - UniqueArrayHandle(const UniqueArrayHandle&) noexcept = delete; - UniqueArrayHandle& operator=(const UniqueArrayHandle&) noexcept = delete; + UniqueArrayHandle(const UniqueArrayHandle&) noexcept = delete; + UniqueArrayHandle& operator=(const UniqueArrayHandle&) noexcept = delete; - UniqueArrayHandle(UniqueArrayHandle&& other) noexcept { swap(other); } + UniqueArrayHandle(UniqueArrayHandle&& other) noexcept { swap(other); } - UniqueArrayHandle& operator=(UniqueArrayHandle&& other) noexcept - { - swap(other); - return *this; - } + UniqueArrayHandle& operator=(UniqueArrayHandle&& other) noexcept + { + swap(other); + return *this; + } - const T& operator[](const size_t index) const noexcept - { - return _array[index]; - } + const T& operator[](const size_t index) const noexcept + { + return _array[index]; + } - T& operator[](const size_t index) noexcept { return _array[index]; } + T& operator[](const size_t index) noexcept { return _array[index]; } - const T* get() const noexcept { return _array.data(); } - T* get() noexcept { return _array.data(); } + const T* get() const noexcept { return _array.data(); } + T* get() noexcept { return _array.data(); } private: - void swap(UniqueArrayHandle& other) noexcept - { - std::swap(_array, other._array); - std::swap(_deleter, other._deleter); - std::swap(_size, other._size); - } - - Vector _array{}; - Deleter _deleter{}; - uint32_t _size{}; + void swap(UniqueArrayHandle& other) noexcept + { + std::swap(_array, other._array); + std::swap(_deleter, other._deleter); + std::swap(_size, other._size); + } + + Vector _array{}; + Deleter _deleter{}; + uint32_t _size{}; }; template<typename T> class OptionalParameter { public: - using Handle = typename T::Handle; + using Handle = typename T::Handle; - OptionalParameter(const T& value) noexcept - : _handle{value.get()} - {} + OptionalParameter(const T& value) noexcept + : _handle{value.get()} + {} - OptionalParameter() noexcept - : _handle{} - {} + OptionalParameter() noexcept + : _handle{} + {} - OptionalParameter(const OptionalParameter&) = delete; - OptionalParameter& operator=(const OptionalParameter&) = delete; + OptionalParameter(const OptionalParameter&) = delete; + OptionalParameter& operator=(const OptionalParameter&) = delete; - OptionalParameter(OptionalParameter&&) = delete; - OptionalParameter& operator=(OptionalParameter&&) = delete; + OptionalParameter(OptionalParameter&&) = delete; + OptionalParameter& operator=(OptionalParameter&&) = delete; - const Handle get() const noexcept { return _handle; } + const Handle get() const noexcept { return _handle; } private: - Handle _handle{}; + Handle _handle{}; }; template<typename T> @@ -559,20 +558,20 @@ using GlobalObject = UniqueDispatchableHandle<T, GlobalDeleter<T>>; template<typename T> using InstanceChild = - UniqueNonDispatchableHandle<T, DependantDeleter<T, VkInstance>>; + UniqueNonDispatchableHandle<T, DependantDeleter<T, VkInstance>>; template<typename T> using DispatchableDeviceChild = - UniqueDispatchableHandle<T, DependantDeleter<T, VkDevice>>; + UniqueDispatchableHandle<T, DependantDeleter<T, VkDevice>>; template<typename T> using NonDispatchableDeviceChild = - UniqueNonDispatchableHandle<T, DependantDeleter<T, VkDevice>>; + UniqueNonDispatchableHandle<T, DependantDeleter<T, VkDevice>>; template<typename Vector, typename Pool, typename FreeFuncResult> using PoolChild = UniqueArrayHandle< - Vector, - PoolDeleter<typename Vector::value_type, Pool, FreeFuncResult>>; + Vector, + PoolDeleter<typename Vector::value_type, Pool, FreeFuncResult>>; using Device = GlobalObject<VkDevice>; using Instance = GlobalObject<VkInstance>; @@ -606,7 +605,7 @@ using CommandBuffers = PoolChild<VkCommandBufferVector, VkCommandPool, void>; template<class VkDescriptorSetVector> using DescriptorSets = - PoolChild<VkDescriptorSetVector, VkDescriptorPool, VkResult>; + PoolChild<VkDescriptorSetVector, VkDescriptorPool, VkResult>; // VK_KHR_swapchain using SwapchainKHR = NonDispatchableDeviceChild<VkSwapchainKHR>; @@ -622,11 +621,11 @@ struct IndexSequence {}; template<size_t N, size_t... Next> struct IndexSequenceHelper - : public IndexSequenceHelper<N - 1U, N - 1U, Next...> {}; + : public IndexSequenceHelper<N - 1U, N - 1U, Next...> {}; template<size_t... Next> struct IndexSequenceHelper<0U, Next...> { - using type = IndexSequence<Next...>; + using type = IndexSequence<Next...>; }; template<size_t N> @@ -639,7 +638,7 @@ make_handle_array_h(Parent parent, std::array<typename T::Handle, count> handles, IndexSequence<Is...>) noexcept { - return {T{handles[Is], {parent, destroyFunc}}...}; + return {T{handles[Is], {parent, destroyFunc}}...}; } template<class T, class Parent, class DestroyFunc, size_t count> @@ -648,8 +647,8 @@ make_handle_array(Parent parent, DestroyFunc destroyFunc, std::array<typename T::Handle, count> handles) noexcept { - return make_handle_array_h<T, Parent, DestroyFunc, count>( - parent, destroyFunc, handles, makeIndexSequence<count>()); + return make_handle_array_h<T, Parent, DestroyFunc, count>( + parent, destroyFunc, handles, makeIndexSequence<count>()); } namespace detail { @@ -658,20 +657,20 @@ template<class Value, class Vector, class Func, class... Args> inline VkResult wrapVectorAccessor(Vector& vector, Func func, Args... args) noexcept { - uint32_t count = 0u; - VkResult r = func(args..., &count, nullptr); - if (r > VK_INCOMPLETE) { - vector.clear(); - return r; - } - - vector = Vector(count); - if ((r = func(args..., &count, vector.data()))) { - vector.clear(); - return r; - } - - return VK_SUCCESS; + uint32_t count = 0u; + VkResult r = func(args..., &count, nullptr); + if (r > VK_INCOMPLETE) { + vector.clear(); + return r; + } + + vector = Vector(count); + if ((r = func(args..., &count, vector.data()))) { + vector.clear(); + return r; + } + + return VK_SUCCESS; } } // namespace detail @@ -679,148 +678,147 @@ wrapVectorAccessor(Vector& vector, Func func, Args... args) noexcept class VulkanApi; struct MappedMemory { - MappedMemory() noexcept = default; - - MappedMemory(const VulkanApi& api, - VkDevice device, - VkDeviceMemory memory, - void* data) noexcept - : _api{&api} - , _device{device} - , _memory{memory} - , _data{data} - {} - - MappedMemory(const MappedMemory&) = delete; - MappedMemory& operator=(const MappedMemory&) = delete; - - MappedMemory(MappedMemory&& mappedMemory) noexcept - : _api{mappedMemory._api} - , _device{mappedMemory._device} - , _memory{mappedMemory._memory} - , _data{mappedMemory._data} - { - mappedMemory._device = {}; - mappedMemory._memory = {}; - mappedMemory._data = {}; - } - - MappedMemory& operator=(MappedMemory&& mappedMemory) noexcept - { - std::swap(_api, mappedMemory._api); - std::swap(_device, mappedMemory._device); - std::swap(_memory, mappedMemory._memory); - std::swap(_data, mappedMemory._data); - return *this; - } - - ~MappedMemory() noexcept; - - const void* get() const noexcept { return _data; } - void* get() noexcept { return _data; } + MappedMemory() noexcept = default; + + MappedMemory(const VulkanApi& api, + VkDevice device, + VkDeviceMemory memory, + void* data) noexcept + : _api{&api} + , _device{device} + , _memory{memory} + , _data{data} + {} + + MappedMemory(const MappedMemory&) = delete; + MappedMemory& operator=(const MappedMemory&) = delete; + + MappedMemory(MappedMemory&& mappedMemory) noexcept + : _api{mappedMemory._api} + , _device{mappedMemory._device} + , _memory{mappedMemory._memory} + , _data{mappedMemory._data} + { + mappedMemory._device = {}; + mappedMemory._memory = {}; + mappedMemory._data = {}; + } + + MappedMemory& operator=(MappedMemory&& mappedMemory) noexcept + { + std::swap(_api, mappedMemory._api); + std::swap(_device, mappedMemory._device); + std::swap(_memory, mappedMemory._memory); + std::swap(_data, mappedMemory._data); + return *this; + } + + ~MappedMemory() noexcept; + + const void* get() const noexcept { return _data; } + void* get() noexcept { return _data; } private: - const VulkanApi* _api{}; - VkDevice _device{}; - VkDeviceMemory _memory{}; - void* _data{}; + const VulkanApi* _api{}; + VkDevice _device{}; + VkDeviceMemory _memory{}; + void* _data{}; }; class VulkanInitApi { public: - template<typename NotFoundFunc> - VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr, - NotFoundFunc notFound) noexcept - { -#define SK_INIT(name) \ - do { \ - if (!(name = PFN_##name(getInstanceProcAddr(NULL, #name)))) { \ - notFound(#name); \ - } \ - } while (0) - - vkGetInstanceProcAddr = pGetInstanceProcAddr; - SK_INIT(vkCreateInstance); - vkDestroyInstance = {}; // Loaded after we create an instance - SK_INIT(vkEnumerateInstanceExtensionProperties); - SK_INIT(vkEnumerateInstanceLayerProperties); - - if (!vkCreateInstance || !vkEnumerateInstanceExtensionProperties || - !vkEnumerateInstanceLayerProperties) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - return VK_SUCCESS; + template<typename NotFoundFunc> + VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr, + NotFoundFunc notFound) noexcept + { +#define SK_INIT(name) \ + do { \ + if (!(name = PFN_##name(getInstanceProcAddr(NULL, #name)))) { \ + notFound(#name); \ + } \ + } while (0) + + vkGetInstanceProcAddr = pGetInstanceProcAddr; + SK_INIT(vkCreateInstance); + vkDestroyInstance = {}; // Loaded after we create an instance + SK_INIT(vkEnumerateInstanceExtensionProperties); + SK_INIT(vkEnumerateInstanceLayerProperties); + + if (!vkCreateInstance || !vkEnumerateInstanceExtensionProperties || + !vkEnumerateInstanceLayerProperties) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + return VK_SUCCESS; #undef SK_INIT - } - - VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr) noexcept - { - return init(pGetInstanceProcAddr, [](const char*) {}); - } - - PFN_vkVoidFunction - getInstanceProcAddr(VkInstance instance, - const char* const name) const noexcept - { - return vkGetInstanceProcAddr(instance, name); - } - - VkResult createInstance(const VkInstanceCreateInfo& createInfo, - Instance& instance) noexcept - { - VkInstance h = {}; - if (const VkResult r = vkCreateInstance(&createInfo, nullptr, &h)) { - return r; - } else if (!h) { - // Shouldn't actually happen, but this lets the compiler know that - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (!vkDestroyInstance) { - vkDestroyInstance = PFN_vkDestroyInstance( - getInstanceProcAddr(instance, "vkDestroyInstance")); - } - - instance = {h, {vkDestroyInstance}}; - return VK_SUCCESS; - } - - template<class Vector> - VkResult - enumerateInstanceExtensionProperties(Vector& properties) const noexcept - { - return detail::wrapVectorAccessor<VkExtensionProperties>( - properties, vkEnumerateInstanceExtensionProperties, nullptr); - } - - template<class Vector> - VkResult - enumerateInstanceExtensionProperties(const char* const layerName, - Vector& properties) const noexcept - { - return detail::wrapVectorAccessor<VkExtensionProperties>( - properties, vkEnumerateInstanceExtensionProperties, layerName); - } - - template<class Vector> - VkResult enumerateInstanceLayerProperties(Vector& properties) const noexcept - { - return detail::wrapVectorAccessor<VkLayerProperties>( - properties, vkEnumerateInstanceLayerProperties); - } + } + + VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr) noexcept + { + return init(pGetInstanceProcAddr, [](const char*) {}); + } + + PFN_vkVoidFunction getInstanceProcAddr(VkInstance instance, + const char* const name) const noexcept + { + return vkGetInstanceProcAddr(instance, name); + } + + VkResult createInstance(const VkInstanceCreateInfo& createInfo, + Instance& instance) noexcept + { + VkInstance h = {}; + if (const VkResult r = vkCreateInstance(&createInfo, nullptr, &h)) { + return r; + } else if (!h) { + // Shouldn't actually happen, but this lets the compiler know that + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (!vkDestroyInstance) { + vkDestroyInstance = PFN_vkDestroyInstance( + getInstanceProcAddr(instance, "vkDestroyInstance")); + } + + instance = {h, {vkDestroyInstance}}; + return VK_SUCCESS; + } + + template<class Vector> + VkResult enumerateInstanceExtensionProperties( + Vector& properties) const noexcept + { + return detail::wrapVectorAccessor<VkExtensionProperties>( + properties, vkEnumerateInstanceExtensionProperties, nullptr); + } + + template<class Vector> + VkResult enumerateInstanceExtensionProperties( + const char* const layerName, + Vector& properties) const noexcept + { + return detail::wrapVectorAccessor<VkExtensionProperties>( + properties, vkEnumerateInstanceExtensionProperties, layerName); + } + + template<class Vector> + VkResult enumerateInstanceLayerProperties(Vector& properties) const noexcept + { + return detail::wrapVectorAccessor<VkLayerProperties>( + properties, vkEnumerateInstanceLayerProperties); + } private: - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; #define SK_FUNC(name) \ - PFN_##name name {} + PFN_##name name {} - SK_FUNC(vkCreateInstance); - SK_FUNC(vkDestroyInstance); - SK_FUNC(vkEnumerateInstanceExtensionProperties); - SK_FUNC(vkEnumerateInstanceLayerProperties); + SK_FUNC(vkCreateInstance); + SK_FUNC(vkDestroyInstance); + SK_FUNC(vkEnumerateInstanceExtensionProperties); + SK_FUNC(vkEnumerateInstanceLayerProperties); #undef SK_FUNC }; @@ -828,1529 +826,1472 @@ private: class VulkanApi { public: - template<typename NotFoundFunc> - VkResult init(const VulkanInitApi& initApi, - const Instance& instance, - NotFoundFunc notFound) noexcept - { - VkResult r = VK_SUCCESS; - - const auto notFoundWrapper = [&r, notFound](const char* name) { - r = VK_INCOMPLETE; - notFound(name); - }; - -#define SK_INIT(name) \ - do { \ - if (!(name = PFN_##name( \ - initApi.getInstanceProcAddr(instance, #name)))) { \ - notFoundWrapper(#name); \ - } \ - } while (0) - - SK_INIT(vkAllocateCommandBuffers); - SK_INIT(vkAllocateDescriptorSets); - SK_INIT(vkAllocateMemory); - SK_INIT(vkBeginCommandBuffer); - SK_INIT(vkBindBufferMemory); - SK_INIT(vkBindImageMemory); - SK_INIT(vkCmdBeginQuery); - SK_INIT(vkCmdBeginRenderPass); - SK_INIT(vkCmdBindDescriptorSets); - SK_INIT(vkCmdBindIndexBuffer); - SK_INIT(vkCmdBindPipeline); - SK_INIT(vkCmdBindVertexBuffers); - SK_INIT(vkCmdBlitImage); - SK_INIT(vkCmdClearAttachments); - SK_INIT(vkCmdClearColorImage); - SK_INIT(vkCmdClearDepthStencilImage); - SK_INIT(vkCmdCopyBuffer); - SK_INIT(vkCmdCopyBufferToImage); - SK_INIT(vkCmdCopyImage); - SK_INIT(vkCmdCopyImageToBuffer); - SK_INIT(vkCmdCopyQueryPoolResults); - SK_INIT(vkCmdDispatch); - SK_INIT(vkCmdDispatchIndirect); - SK_INIT(vkCmdDraw); - SK_INIT(vkCmdDrawIndexed); - SK_INIT(vkCmdDrawIndexedIndirect); - SK_INIT(vkCmdDrawIndirect); - SK_INIT(vkCmdEndQuery); - SK_INIT(vkCmdEndRenderPass); - SK_INIT(vkCmdExecuteCommands); - SK_INIT(vkCmdFillBuffer); - SK_INIT(vkCmdNextSubpass); - SK_INIT(vkCmdPipelineBarrier); - SK_INIT(vkCmdPushConstants); - SK_INIT(vkCmdResetEvent); - SK_INIT(vkCmdResetQueryPool); - SK_INIT(vkCmdResolveImage); - SK_INIT(vkCmdSetBlendConstants); - SK_INIT(vkCmdSetDepthBias); - SK_INIT(vkCmdSetDepthBounds); - SK_INIT(vkCmdSetEvent); - SK_INIT(vkCmdSetLineWidth); - SK_INIT(vkCmdSetScissor); - SK_INIT(vkCmdSetStencilCompareMask); - SK_INIT(vkCmdSetStencilReference); - SK_INIT(vkCmdSetStencilWriteMask); - SK_INIT(vkCmdSetViewport); - SK_INIT(vkCmdUpdateBuffer); - SK_INIT(vkCmdWaitEvents); - SK_INIT(vkCmdWriteTimestamp); - SK_INIT(vkCreateBuffer); - SK_INIT(vkCreateBufferView); - SK_INIT(vkCreateCommandPool); - SK_INIT(vkCreateComputePipelines); - SK_INIT(vkCreateDescriptorPool); - SK_INIT(vkCreateDescriptorSetLayout); - SK_INIT(vkCreateDevice); - SK_INIT(vkCreateEvent); - SK_INIT(vkCreateFence); - SK_INIT(vkCreateFramebuffer); - SK_INIT(vkCreateGraphicsPipelines); - SK_INIT(vkCreateImage); - SK_INIT(vkCreateImageView); - SK_INIT(vkCreateInstance); - SK_INIT(vkCreatePipelineCache); - SK_INIT(vkCreatePipelineLayout); - SK_INIT(vkCreateQueryPool); - SK_INIT(vkCreateRenderPass); - SK_INIT(vkCreateSampler); - SK_INIT(vkCreateSemaphore); - SK_INIT(vkCreateShaderModule); - SK_INIT(vkDestroyBuffer); - SK_INIT(vkDestroyBufferView); - SK_INIT(vkDestroyCommandPool); - SK_INIT(vkDestroyDescriptorPool); - SK_INIT(vkDestroyDescriptorSetLayout); - SK_INIT(vkDestroyDevice); - SK_INIT(vkDestroyEvent); - SK_INIT(vkDestroyFence); - SK_INIT(vkDestroyFramebuffer); - SK_INIT(vkDestroyImage); - SK_INIT(vkDestroyImageView); - SK_INIT(vkDestroyPipeline); - SK_INIT(vkDestroyPipelineCache); - SK_INIT(vkDestroyPipelineLayout); - SK_INIT(vkDestroyQueryPool); - SK_INIT(vkDestroyRenderPass); - SK_INIT(vkDestroySampler); - SK_INIT(vkDestroySemaphore); - SK_INIT(vkDestroyShaderModule); - SK_INIT(vkDeviceWaitIdle); - SK_INIT(vkEndCommandBuffer); - SK_INIT(vkEnumerateDeviceExtensionProperties); - SK_INIT(vkEnumerateDeviceLayerProperties); - SK_INIT(vkEnumeratePhysicalDevices); - SK_INIT(vkFlushMappedMemoryRanges); - SK_INIT(vkFreeCommandBuffers); - SK_INIT(vkFreeDescriptorSets); - SK_INIT(vkFreeMemory); - SK_INIT(vkGetBufferMemoryRequirements); - SK_INIT(vkGetDeviceMemoryCommitment); - SK_INIT(vkGetDeviceProcAddr); - SK_INIT(vkGetDeviceQueue); - SK_INIT(vkGetEventStatus); - SK_INIT(vkGetFenceStatus); - SK_INIT(vkGetImageMemoryRequirements); - SK_INIT(vkGetImageSparseMemoryRequirements); - SK_INIT(vkGetImageSubresourceLayout); - SK_INIT(vkGetInstanceProcAddr); - SK_INIT(vkGetPhysicalDeviceFeatures); - SK_INIT(vkGetPhysicalDeviceFormatProperties); - SK_INIT(vkGetPhysicalDeviceImageFormatProperties); - SK_INIT(vkGetPhysicalDeviceMemoryProperties); - SK_INIT(vkGetPhysicalDeviceProperties); - SK_INIT(vkGetPhysicalDeviceQueueFamilyProperties); - SK_INIT(vkGetPhysicalDeviceSparseImageFormatProperties); - SK_INIT(vkGetPipelineCacheData); - SK_INIT(vkGetQueryPoolResults); - SK_INIT(vkGetRenderAreaGranularity); - SK_INIT(vkInvalidateMappedMemoryRanges); - SK_INIT(vkMapMemory); - SK_INIT(vkMergePipelineCaches); - SK_INIT(vkQueueBindSparse); - SK_INIT(vkQueueSubmit); - SK_INIT(vkQueueWaitIdle); - SK_INIT(vkResetCommandBuffer); - SK_INIT(vkResetCommandPool); - SK_INIT(vkResetDescriptorPool); - SK_INIT(vkResetEvent); - SK_INIT(vkResetFences); - SK_INIT(vkSetEvent); - SK_INIT(vkUnmapMemory); - SK_INIT(vkUpdateDescriptorSets); - SK_INIT(vkWaitForFences); - - // VK_EXT_debug_report - SK_INIT(vkCreateDebugReportCallbackEXT); - SK_INIT(vkDebugReportMessageEXT); - SK_INIT(vkDestroyDebugReportCallbackEXT); - - // VK_KHR_surface - SK_INIT(vkDestroySurfaceKHR); - SK_INIT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); - SK_INIT(vkGetPhysicalDeviceSurfaceFormatsKHR); - SK_INIT(vkGetPhysicalDeviceSurfacePresentModesKHR); - SK_INIT(vkGetPhysicalDeviceSurfaceSupportKHR); - - // VK_KHR_swapchain - SK_INIT(vkAcquireNextImageKHR); - SK_INIT(vkCreateSwapchainKHR); - SK_INIT(vkDestroySwapchainKHR); - SK_INIT(vkGetDeviceGroupPresentCapabilitiesKHR); - SK_INIT(vkGetDeviceGroupSurfacePresentModesKHR); - SK_INIT(vkGetPhysicalDevicePresentRectanglesKHR); - SK_INIT(vkGetSwapchainImagesKHR); - SK_INIT(vkQueuePresentKHR); + template<typename NotFoundFunc> + VkResult init(const VulkanInitApi& initApi, + const Instance& instance, + NotFoundFunc notFound) noexcept + { + VkResult r = VK_SUCCESS; + + const auto notFoundWrapper = [&r, notFound](const char* name) { + r = VK_INCOMPLETE; + notFound(name); + }; + +#define SK_INIT(name) \ + do { \ + if (!(name = PFN_##name(initApi.getInstanceProcAddr(instance, #name)))) { \ + notFoundWrapper(#name); \ + } \ + } while (0) + + SK_INIT(vkAllocateCommandBuffers); + SK_INIT(vkAllocateDescriptorSets); + SK_INIT(vkAllocateMemory); + SK_INIT(vkBeginCommandBuffer); + SK_INIT(vkBindBufferMemory); + SK_INIT(vkBindImageMemory); + SK_INIT(vkCmdBeginQuery); + SK_INIT(vkCmdBeginRenderPass); + SK_INIT(vkCmdBindDescriptorSets); + SK_INIT(vkCmdBindIndexBuffer); + SK_INIT(vkCmdBindPipeline); + SK_INIT(vkCmdBindVertexBuffers); + SK_INIT(vkCmdBlitImage); + SK_INIT(vkCmdClearAttachments); + SK_INIT(vkCmdClearColorImage); + SK_INIT(vkCmdClearDepthStencilImage); + SK_INIT(vkCmdCopyBuffer); + SK_INIT(vkCmdCopyBufferToImage); + SK_INIT(vkCmdCopyImage); + SK_INIT(vkCmdCopyImageToBuffer); + SK_INIT(vkCmdCopyQueryPoolResults); + SK_INIT(vkCmdDispatch); + SK_INIT(vkCmdDispatchIndirect); + SK_INIT(vkCmdDraw); + SK_INIT(vkCmdDrawIndexed); + SK_INIT(vkCmdDrawIndexedIndirect); + SK_INIT(vkCmdDrawIndirect); + SK_INIT(vkCmdEndQuery); + SK_INIT(vkCmdEndRenderPass); + SK_INIT(vkCmdExecuteCommands); + SK_INIT(vkCmdFillBuffer); + SK_INIT(vkCmdNextSubpass); + SK_INIT(vkCmdPipelineBarrier); + SK_INIT(vkCmdPushConstants); + SK_INIT(vkCmdResetEvent); + SK_INIT(vkCmdResetQueryPool); + SK_INIT(vkCmdResolveImage); + SK_INIT(vkCmdSetBlendConstants); + SK_INIT(vkCmdSetDepthBias); + SK_INIT(vkCmdSetDepthBounds); + SK_INIT(vkCmdSetEvent); + SK_INIT(vkCmdSetLineWidth); + SK_INIT(vkCmdSetScissor); + SK_INIT(vkCmdSetStencilCompareMask); + SK_INIT(vkCmdSetStencilReference); + SK_INIT(vkCmdSetStencilWriteMask); + SK_INIT(vkCmdSetViewport); + SK_INIT(vkCmdUpdateBuffer); + SK_INIT(vkCmdWaitEvents); + SK_INIT(vkCmdWriteTimestamp); + SK_INIT(vkCreateBuffer); + SK_INIT(vkCreateBufferView); + SK_INIT(vkCreateCommandPool); + SK_INIT(vkCreateComputePipelines); + SK_INIT(vkCreateDescriptorPool); + SK_INIT(vkCreateDescriptorSetLayout); + SK_INIT(vkCreateDevice); + SK_INIT(vkCreateEvent); + SK_INIT(vkCreateFence); + SK_INIT(vkCreateFramebuffer); + SK_INIT(vkCreateGraphicsPipelines); + SK_INIT(vkCreateImage); + SK_INIT(vkCreateImageView); + SK_INIT(vkCreateInstance); + SK_INIT(vkCreatePipelineCache); + SK_INIT(vkCreatePipelineLayout); + SK_INIT(vkCreateQueryPool); + SK_INIT(vkCreateRenderPass); + SK_INIT(vkCreateSampler); + SK_INIT(vkCreateSemaphore); + SK_INIT(vkCreateShaderModule); + SK_INIT(vkDestroyBuffer); + SK_INIT(vkDestroyBufferView); + SK_INIT(vkDestroyCommandPool); + SK_INIT(vkDestroyDescriptorPool); + SK_INIT(vkDestroyDescriptorSetLayout); + SK_INIT(vkDestroyDevice); + SK_INIT(vkDestroyEvent); + SK_INIT(vkDestroyFence); + SK_INIT(vkDestroyFramebuffer); + SK_INIT(vkDestroyImage); + SK_INIT(vkDestroyImageView); + SK_INIT(vkDestroyPipeline); + SK_INIT(vkDestroyPipelineCache); + SK_INIT(vkDestroyPipelineLayout); + SK_INIT(vkDestroyQueryPool); + SK_INIT(vkDestroyRenderPass); + SK_INIT(vkDestroySampler); + SK_INIT(vkDestroySemaphore); + SK_INIT(vkDestroyShaderModule); + SK_INIT(vkDeviceWaitIdle); + SK_INIT(vkEndCommandBuffer); + SK_INIT(vkEnumerateDeviceExtensionProperties); + SK_INIT(vkEnumerateDeviceLayerProperties); + SK_INIT(vkEnumeratePhysicalDevices); + SK_INIT(vkFlushMappedMemoryRanges); + SK_INIT(vkFreeCommandBuffers); + SK_INIT(vkFreeDescriptorSets); + SK_INIT(vkFreeMemory); + SK_INIT(vkGetBufferMemoryRequirements); + SK_INIT(vkGetDeviceMemoryCommitment); + SK_INIT(vkGetDeviceProcAddr); + SK_INIT(vkGetDeviceQueue); + SK_INIT(vkGetEventStatus); + SK_INIT(vkGetFenceStatus); + SK_INIT(vkGetImageMemoryRequirements); + SK_INIT(vkGetImageSparseMemoryRequirements); + SK_INIT(vkGetImageSubresourceLayout); + SK_INIT(vkGetInstanceProcAddr); + SK_INIT(vkGetPhysicalDeviceFeatures); + SK_INIT(vkGetPhysicalDeviceFormatProperties); + SK_INIT(vkGetPhysicalDeviceImageFormatProperties); + SK_INIT(vkGetPhysicalDeviceMemoryProperties); + SK_INIT(vkGetPhysicalDeviceProperties); + SK_INIT(vkGetPhysicalDeviceQueueFamilyProperties); + SK_INIT(vkGetPhysicalDeviceSparseImageFormatProperties); + SK_INIT(vkGetPipelineCacheData); + SK_INIT(vkGetQueryPoolResults); + SK_INIT(vkGetRenderAreaGranularity); + SK_INIT(vkInvalidateMappedMemoryRanges); + SK_INIT(vkMapMemory); + SK_INIT(vkMergePipelineCaches); + SK_INIT(vkQueueBindSparse); + SK_INIT(vkQueueSubmit); + SK_INIT(vkQueueWaitIdle); + SK_INIT(vkResetCommandBuffer); + SK_INIT(vkResetCommandPool); + SK_INIT(vkResetDescriptorPool); + SK_INIT(vkResetEvent); + SK_INIT(vkResetFences); + SK_INIT(vkSetEvent); + SK_INIT(vkUnmapMemory); + SK_INIT(vkUpdateDescriptorSets); + SK_INIT(vkWaitForFences); + + // VK_EXT_debug_report + SK_INIT(vkCreateDebugReportCallbackEXT); + SK_INIT(vkDebugReportMessageEXT); + SK_INIT(vkDestroyDebugReportCallbackEXT); + + // VK_KHR_surface + SK_INIT(vkDestroySurfaceKHR); + SK_INIT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + SK_INIT(vkGetPhysicalDeviceSurfaceFormatsKHR); + SK_INIT(vkGetPhysicalDeviceSurfacePresentModesKHR); + SK_INIT(vkGetPhysicalDeviceSurfaceSupportKHR); + + // VK_KHR_swapchain + SK_INIT(vkAcquireNextImageKHR); + SK_INIT(vkCreateSwapchainKHR); + SK_INIT(vkDestroySwapchainKHR); + SK_INIT(vkGetDeviceGroupPresentCapabilitiesKHR); + SK_INIT(vkGetDeviceGroupSurfacePresentModesKHR); + SK_INIT(vkGetPhysicalDevicePresentRectanglesKHR); + SK_INIT(vkGetSwapchainImagesKHR); + SK_INIT(vkQueuePresentKHR); #undef SK_INIT - return r; - } - - VkResult - init(const VulkanInitApi& initApi, const Instance& instance) noexcept - { - return init(initApi, instance, [](const char*) {}); - } - - template<class VkCommandBufferVector> - VkResult allocateCommandBuffers( - const Device& device, - const VkCommandBufferAllocateInfo& allocateInfo, - CommandBuffers<VkCommandBufferVector>& commandBuffers) const noexcept - { - VkCommandBufferVector rawCommandBuffers = VkCommandBufferVector( - allocateInfo.commandBufferCount); - - if (const VkResult r = vkAllocateCommandBuffers( - device, &allocateInfo, rawCommandBuffers.data())) { - return r; - } - - commandBuffers = CommandBuffers<VkCommandBufferVector>{ - allocateInfo.commandBufferCount, - std::move(rawCommandBuffers), - PoolDeleter<VkCommandBuffer, VkCommandPool, void>{ - device, - allocateInfo.commandPool, - allocateInfo.commandBufferCount, - vkFreeCommandBuffers}}; - return VK_SUCCESS; - } - - template<class VkDescriptorSetVector> - VkResult allocateDescriptorSets( - const Device& device, - const VkDescriptorSetAllocateInfo& allocateInfo, - DescriptorSets<VkDescriptorSetVector>& descriptorSets) const noexcept - { - auto descriptorSetVector = VkDescriptorSetVector( - allocateInfo.descriptorSetCount); - - if (const VkResult r = vkAllocateDescriptorSets( - device, &allocateInfo, descriptorSetVector.data())) { - return r; - } - - descriptorSets = DescriptorSets<VkDescriptorSetVector>{ - allocateInfo.descriptorSetCount, - std::move(descriptorSetVector), - PoolDeleter<VkDescriptorSet, VkDescriptorPool, VkResult>{ - device, - allocateInfo.descriptorPool, - allocateInfo.descriptorSetCount, - vkFreeDescriptorSets}}; - return VK_SUCCESS; - } - - VkResult bindBufferMemory(const Device& device, - const Buffer& buffer, - const DeviceMemory& memory, - VkDeviceSize memoryOffset) const noexcept - { - return vkBindBufferMemory - ? vkBindBufferMemory(device, buffer, memory, memoryOffset) - : VK_ERROR_FEATURE_NOT_PRESENT; - } - - VkResult createBuffer(const Device& device, - const VkBufferCreateInfo& createInfo, - Buffer& buffer) const noexcept - { - VkBuffer h = {}; - const VkResult r = vkCreateBuffer(device, &createInfo, nullptr, &h); - return wrapResult(r, h, {device, vkDestroyBuffer}, buffer); - } - - VkResult createBufferView(const Device& device, - const VkBufferViewCreateInfo& createInfo, - BufferView& bufferView) const noexcept - { - VkBufferView h = {}; - const VkResult r = vkCreateBufferView(device, &createInfo, nullptr, &h); - return wrapResult(r, h, {device, vkDestroyBufferView}, bufferView); - } - - VkResult createCommandPool(const Device& device, - const VkCommandPoolCreateInfo& createInfo, - CommandPool& commandPool) const noexcept - { - VkCommandPool h = {}; - const VkResult r = - vkCreateCommandPool(device, &createInfo, nullptr, &h); - return wrapResult(r, h, {device, vkDestroyCommandPool}, commandPool); - } - - VkResult createDescriptorPool(const Device& device, - const VkDescriptorPoolCreateInfo& createInfo, - DescriptorPool& descriptorPool) const noexcept - { - VkDescriptorPool h = {}; - const VkResult r = - vkCreateDescriptorPool(device, &createInfo, nullptr, &h); - - return wrapResult(r, - h, - {device, vkDestroyDescriptorPool}, - descriptorPool); - } - - VkResult createDescriptorSetLayout( - const Device& device, - const VkDescriptorSetLayoutCreateInfo& createInfo, - DescriptorSetLayout& descriptorSetLayout) const noexcept - { - VkDescriptorSetLayout h = {}; - const VkResult r = - vkCreateDescriptorSetLayout(device, &createInfo, nullptr, &h); - - return wrapResult(r, - h, - {device, vkDestroyDescriptorSetLayout}, - descriptorSetLayout); - } - - VkResult createDevice(const PhysicalDevice& physicalDevice, - const VkDeviceCreateInfo& createInfo, - Device& result) const noexcept - { - VkDevice h = {}; - const VkResult r = - vkCreateDevice(physicalDevice, &createInfo, nullptr, &h); - - return wrapResult(r, h, {vkDestroyDevice}, result); - } - - VkResult createEvent(const Device& device, - const VkEventCreateInfo& createInfo, - Event& event) const noexcept - { - VkEvent h = {}; - const VkResult r = vkCreateEvent(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyEvent}, event); - } - - VkResult createFence(const Device& device, - const VkFenceCreateInfo& createInfo, - Fence& fence) const noexcept - { - VkFence h = {}; - const VkResult r = vkCreateFence(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyFence}, fence); - } - - VkResult createFramebuffer(const Device& device, - const VkFramebufferCreateInfo& createInfo, - Framebuffer& framebuffer) const noexcept - { - VkFramebuffer h = {}; - const VkResult r = - vkCreateFramebuffer(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyFramebuffer}, framebuffer); - } - - VkResult createImage(const Device& device, - const VkImageCreateInfo& createInfo, - Image& image) const noexcept - { - VkImage h = {}; - const VkResult r = vkCreateImage(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyImage}, image); - } - - VkResult createImageView(const Device& device, - const VkImageViewCreateInfo& createInfo, - ImageView& imageView) const noexcept - { - VkImageView h = {}; - const VkResult r = vkCreateImageView(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyImageView}, imageView); - } - - template<size_t count> - VkResult createGraphicsPipelines( - const Device& device, - const OptionalParameter<PipelineCache>& pipelineCache, - const std::array<VkGraphicsPipelineCreateInfo, count>& createInfos, - std::array<Pipeline, count>& pipelines) const noexcept - { - std::array<VkPipeline, count> pipelineHandles{}; - - if (const VkResult r = vkCreateGraphicsPipelines( - device, - pipelineCache.get(), - static_cast<uint32_t>(createInfos.size()), - createInfos.data(), - nullptr, - pipelineHandles.data())) { - return r; - } - - pipelines = make_handle_array<Pipeline>(device.get(), - vkDestroyPipeline, - pipelineHandles); - return VK_SUCCESS; - } - - VkResult createPipelineCache(const Device& device, - const VkPipelineCacheCreateInfo& createInfo, - PipelineCache& pipelineCache) const noexcept - { - VkPipelineCache h = {}; - const VkResult r = - vkCreatePipelineCache(device, &createInfo, nullptr, &h); - - return wrapResult(r, - h, - {device, vkDestroyPipelineCache}, - pipelineCache); - } - - VkResult createPipelineLayout(const Device& device, - const VkPipelineLayoutCreateInfo& createInfo, - PipelineLayout& pipelineLayout) const noexcept - { - VkPipelineLayout h = {}; - const VkResult r = - vkCreatePipelineLayout(device, &createInfo, nullptr, &h); - - return wrapResult(r, - h, - {device, vkDestroyPipelineLayout}, - pipelineLayout); - } - - VkResult createQueryPool(const Device& device, - const VkQueryPoolCreateInfo& createInfo, - QueryPool& queryPool) const noexcept - { - VkQueryPool h = {}; - const VkResult r = vkCreateQueryPool(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyQueryPool}, queryPool); - } - - VkResult createRenderPass(const Device& device, - const VkRenderPassCreateInfo& createInfo, - RenderPass& renderPass) const noexcept - { - VkRenderPass h = {}; - const VkResult r = vkCreateRenderPass(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyRenderPass}, renderPass); - } - - VkResult createSampler(const Device& device, - const VkSamplerCreateInfo& createInfo, - Sampler& sampler) const noexcept - { - VkSampler h = {}; - const VkResult r = vkCreateSampler(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroySampler}, sampler); - } - - VkResult createSemaphore(const Device& device, - const VkSemaphoreCreateInfo& createInfo, - Semaphore& semaphore) const noexcept - { - VkSemaphore h = {}; - const VkResult r = vkCreateSemaphore(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroySemaphore}, semaphore); - } - - VkResult createShaderModule(const Device& device, - const VkShaderModuleCreateInfo& createInfo, - ShaderModule& shaderModule) const noexcept - { - VkShaderModule h = {}; - const VkResult r = - vkCreateShaderModule(device, &createInfo, nullptr, &h); - - return wrapResult(r, h, {device, vkDestroyShaderModule}, shaderModule); - } - - VkResult deviceWaitIdle(const Device& device) const noexcept - { - return vkDeviceWaitIdle(device); - } - - template<class Vector> - VkResult - enumerateDeviceExtensionProperties(const PhysicalDevice& physicalDevice, - const char* const layerName, - Vector& properties) const noexcept - { - return detail::wrapVectorAccessor<VkExtensionProperties>( - properties, - vkEnumerateDeviceExtensionProperties, - physicalDevice, - layerName); - } - - template<class Vector> - VkResult - enumerateDeviceExtensionProperties(const PhysicalDevice& physicalDevice, - Vector& properties) const noexcept - { - return detail::wrapVectorAccessor<VkExtensionProperties>( - properties, - vkEnumerateDeviceExtensionProperties, - physicalDevice, - nullptr); - } - - template<class Vector> - VkResult enumeratePhysicalDevices(const Instance& instance, - Vector& physicalDevices) const noexcept - { - uint32_t count = 0u; - VkResult r = vkEnumeratePhysicalDevices(instance, &count, nullptr); - if (r > VK_INCOMPLETE) { - return r; - } - - physicalDevices = Vector(count); - if ((r = vkEnumeratePhysicalDevices(instance, - &count, - physicalDevices.data()))) { - return r; - } - - return VK_SUCCESS; - } - - sk::Queue getDeviceQueue(const Device& device, - const uint32_t queueFamilyIndex, - const uint32_t queueIndex) const noexcept - { - VkQueue queue{}; - vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, &queue); - return sk::Queue{queue}; - } - - VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice) const noexcept - { - VkPhysicalDeviceMemoryProperties properties{}; - vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties); - return properties; - } - - VkPhysicalDeviceProperties getPhysicalDeviceProperties( - const PhysicalDevice& physicalDevice) const noexcept - { - VkPhysicalDeviceProperties properties{}; - vkGetPhysicalDeviceProperties(physicalDevice, &properties); - return properties; - } - - template<class Vector> - VkResult getPhysicalDeviceQueueFamilyProperties( - const PhysicalDevice& physicalDevice, - Vector& queueFamilyProperties) const noexcept - { - uint32_t count = 0u; - vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, - &count, - nullptr); - - queueFamilyProperties = Vector(count); - vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, - &count, - queueFamilyProperties.data()); - - return VK_SUCCESS; - } - - VkMemoryRequirements - getBufferMemoryRequirements(const Device& device, - const Buffer& buffer) const noexcept - { - VkMemoryRequirements requirements; - vkGetBufferMemoryRequirements(device, buffer, &requirements); - return requirements; - } - - VkResult allocateMemory(const Device& device, - const VkMemoryAllocateInfo& info, - DeviceMemory& memory) const noexcept - { - VkDeviceMemory h = {}; - if (const VkResult r = vkAllocateMemory(device, &info, nullptr, &h)) { - return r; - } else if (!h) { - return VK_ERROR_OUT_OF_DEVICE_MEMORY; - } - - memory = DeviceMemory{h, {device, vkFreeMemory}}; - return VK_SUCCESS; - } - - VkResult mapMemory(const Device& device, - const DeviceMemory& memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - MappedMemory& mappedMemory) const noexcept - { - void* data = nullptr; - if (const VkResult r = - vkMapMemory(device, memory, offset, size, flags, &data)) { - return r; - } - - mappedMemory = MappedMemory{*this, device, memory, data}; - return VK_SUCCESS; - } - - VkResult queueSubmit(const Queue& queue, - uint32_t submitCount, - const VkSubmitInfo& submits, - const Fence& fence) const noexcept - { - return vkQueueSubmit(queue, submitCount, &submits, fence); - } - - VkResult queueSubmit(const Queue& queue, - const VkSubmitInfo& submit, - const Fence& fence) const noexcept - { - return vkQueueSubmit(queue, 1u, &submit, fence); - } - - template<size_t descriptorWriteCount, size_t descriptorCopyCount> - void updateDescriptorSets( - const Device& device, - std::array<VkWriteDescriptorSet, descriptorWriteCount> descriptorWrites, - std::array<VkCopyDescriptorSet, descriptorCopyCount> descriptorCopies) - const noexcept - { - vkUpdateDescriptorSets(device, - static_cast<uint32_t>(descriptorWrites.size()), - descriptorWrites.data(), - static_cast<uint32_t>(descriptorCopies.size()), - descriptorCopies.data()); - } - - VkResult resetFence(const Device& device, const Fence& fence) const noexcept - { - VkFence h = fence; - return vkResetFences(device, 1u, &h); - } - - VkResult waitForFence(const Device& device, - const Fence& fence, - uint64_t timeout) const noexcept - { - VkFence h = fence; - return vkWaitForFences(device, 1u, &h, VK_TRUE, timeout); - } - - VkResult - waitForFence(const Device& device, const Fence& fence) const noexcept - { - VkFence h = fence; - return vkWaitForFences(device, 1u, &h, VK_TRUE, UINT64_MAX); - } - - // Scoped command buffer interface - SYBOK_NODISCARD - CommandScope - beginCommandBuffer(VkCommandBuffer commandBuffer, - VkCommandBufferBeginInfo beginInfo) const noexcept; - - // VK_EXT_debug_report - - VkResult createDebugReportCallbackEXT( - const Instance& instance, - const VkDebugReportCallbackCreateInfoEXT& createInfo, - DebugReportCallbackEXT& callback) const noexcept - { - VkDebugReportCallbackEXT h = {}; - - if (const VkResult r = vkCreateDebugReportCallbackEXT( - instance, &createInfo, nullptr, &h)) { - return r; - } else if (!h) { - return VK_ERROR_FEATURE_NOT_PRESENT; - } - - callback = {h, {instance, vkDestroyDebugReportCallbackEXT}}; - return VK_SUCCESS; - } - - // VK_KHR_surface - - VkResult getPhysicalDeviceSurfaceCapabilitiesKHR( - const PhysicalDevice& physicalDevice, - const SurfaceKHR& surface, - VkSurfaceCapabilitiesKHR& capabilities) const noexcept - { - return vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, - surface, - &capabilities); - } - - template<typename Vector> - VkResult - getPhysicalDeviceSurfaceFormatsKHR(const PhysicalDevice& physicalDevice, - const SurfaceKHR& surface, - Vector& surfaceFormats) const noexcept - { - return detail::wrapVectorAccessor<VkSurfaceFormatKHR>( - surfaceFormats, - vkGetPhysicalDeviceSurfaceFormatsKHR, - physicalDevice, - surface.get()); - } - - template<typename Vector> - VkResult getPhysicalDeviceSurfacePresentModesKHR( - const PhysicalDevice& physicalDevice, - const SurfaceKHR& surface, - Vector& presentModes) const noexcept - { - return detail::wrapVectorAccessor<VkPresentModeKHR>( - presentModes, - vkGetPhysicalDeviceSurfacePresentModesKHR, - physicalDevice, - surface.get()); - } - - VkResult - getPhysicalDeviceSurfaceSupportKHR(const PhysicalDevice& physicalDevice, - uint32_t queueFamilyIndex, - const SurfaceKHR& surface, - bool& supported) const noexcept - { - VkBool32 s = {}; - - if (VkResult r = vkGetPhysicalDeviceSurfaceSupportKHR( - physicalDevice, queueFamilyIndex, surface, &s)) { - return r; - } - - supported = s; - return VK_SUCCESS; - } - - // VK_KHR_swapchain - - VkResult acquireNextImageKHR(const Device& device, - const SwapchainKHR& swapchain, - uint64_t timeout, - const Semaphore& semaphore, - const OptionalParameter<Fence>& fence, - uint32_t* pImageIndex) const noexcept - { - return vkAcquireNextImageKHR( - device, swapchain, timeout, semaphore, fence.get(), pImageIndex); - } - - template<class Vector> - VkResult getSwapchainImagesKHR(const Device& device, - const SwapchainKHR& swapchain, - Vector& images) const noexcept - { - return detail::wrapVectorAccessor<VkImage>(images, - vkGetSwapchainImagesKHR, - device.get(), - swapchain.get()); - } - - VkResult createSwapchainKHR(const Device& device, - const VkSwapchainCreateInfoKHR& createInfo, - SwapchainKHR& swapchain) const noexcept - { - VkSwapchainKHR h = {}; - const VkResult r = - vkCreateSwapchainKHR(device, &createInfo, nullptr, &h); - - if (r) { - return r; - } else if (!h) { - return VK_ERROR_INCOMPATIBLE_DRIVER; - } - - swapchain = {h, {device, vkDestroySwapchainKHR}}; - return VK_SUCCESS; - } - - VkResult queuePresentKHR(const Queue& queue, - const VkPresentInfoKHR& presentInfo) const noexcept - { - return vkQueuePresentKHR(queue, &presentInfo); - } + return r; + } + + VkResult init(const VulkanInitApi& initApi, const Instance& instance) noexcept + { + return init(initApi, instance, [](const char*) {}); + } + + template<class VkCommandBufferVector> + VkResult allocateCommandBuffers( + const Device& device, + const VkCommandBufferAllocateInfo& allocateInfo, + CommandBuffers<VkCommandBufferVector>& commandBuffers) const noexcept + { + VkCommandBufferVector rawCommandBuffers = + VkCommandBufferVector(allocateInfo.commandBufferCount); + + if (const VkResult r = vkAllocateCommandBuffers( + device, &allocateInfo, rawCommandBuffers.data())) { + return r; + } + + commandBuffers = CommandBuffers<VkCommandBufferVector>{ + allocateInfo.commandBufferCount, + std::move(rawCommandBuffers), + PoolDeleter<VkCommandBuffer, VkCommandPool, void>{ + device, + allocateInfo.commandPool, + allocateInfo.commandBufferCount, + vkFreeCommandBuffers}}; + return VK_SUCCESS; + } + + template<class VkDescriptorSetVector> + VkResult allocateDescriptorSets( + const Device& device, + const VkDescriptorSetAllocateInfo& allocateInfo, + DescriptorSets<VkDescriptorSetVector>& descriptorSets) const noexcept + { + auto descriptorSetVector = + VkDescriptorSetVector(allocateInfo.descriptorSetCount); + + if (const VkResult r = vkAllocateDescriptorSets( + device, &allocateInfo, descriptorSetVector.data())) { + return r; + } + + descriptorSets = DescriptorSets<VkDescriptorSetVector>{ + allocateInfo.descriptorSetCount, + std::move(descriptorSetVector), + PoolDeleter<VkDescriptorSet, VkDescriptorPool, VkResult>{ + device, + allocateInfo.descriptorPool, + allocateInfo.descriptorSetCount, + vkFreeDescriptorSets}}; + return VK_SUCCESS; + } + + VkResult bindBufferMemory(const Device& device, + const Buffer& buffer, + const DeviceMemory& memory, + VkDeviceSize memoryOffset) const noexcept + { + return vkBindBufferMemory + ? vkBindBufferMemory(device, buffer, memory, memoryOffset) + : VK_ERROR_FEATURE_NOT_PRESENT; + } + + VkResult createBuffer(const Device& device, + const VkBufferCreateInfo& createInfo, + Buffer& buffer) const noexcept + { + VkBuffer h = {}; + const VkResult r = vkCreateBuffer(device, &createInfo, nullptr, &h); + return wrapResult(r, h, {device, vkDestroyBuffer}, buffer); + } + + VkResult createBufferView(const Device& device, + const VkBufferViewCreateInfo& createInfo, + BufferView& bufferView) const noexcept + { + VkBufferView h = {}; + const VkResult r = vkCreateBufferView(device, &createInfo, nullptr, &h); + return wrapResult(r, h, {device, vkDestroyBufferView}, bufferView); + } + + VkResult createCommandPool(const Device& device, + const VkCommandPoolCreateInfo& createInfo, + CommandPool& commandPool) const noexcept + { + VkCommandPool h = {}; + const VkResult r = vkCreateCommandPool(device, &createInfo, nullptr, &h); + return wrapResult(r, h, {device, vkDestroyCommandPool}, commandPool); + } + + VkResult createDescriptorPool(const Device& device, + const VkDescriptorPoolCreateInfo& createInfo, + DescriptorPool& descriptorPool) const noexcept + { + VkDescriptorPool h = {}; + const VkResult r = vkCreateDescriptorPool(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyDescriptorPool}, descriptorPool); + } + + VkResult createDescriptorSetLayout( + const Device& device, + const VkDescriptorSetLayoutCreateInfo& createInfo, + DescriptorSetLayout& descriptorSetLayout) const noexcept + { + VkDescriptorSetLayout h = {}; + const VkResult r = + vkCreateDescriptorSetLayout(device, &createInfo, nullptr, &h); + + return wrapResult( + r, h, {device, vkDestroyDescriptorSetLayout}, descriptorSetLayout); + } + + VkResult createDevice(const PhysicalDevice& physicalDevice, + const VkDeviceCreateInfo& createInfo, + Device& result) const noexcept + { + VkDevice h = {}; + const VkResult r = vkCreateDevice(physicalDevice, &createInfo, nullptr, &h); + + return wrapResult(r, h, {vkDestroyDevice}, result); + } + + VkResult createEvent(const Device& device, + const VkEventCreateInfo& createInfo, + Event& event) const noexcept + { + VkEvent h = {}; + const VkResult r = vkCreateEvent(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyEvent}, event); + } + + VkResult createFence(const Device& device, + const VkFenceCreateInfo& createInfo, + Fence& fence) const noexcept + { + VkFence h = {}; + const VkResult r = vkCreateFence(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyFence}, fence); + } + + VkResult createFramebuffer(const Device& device, + const VkFramebufferCreateInfo& createInfo, + Framebuffer& framebuffer) const noexcept + { + VkFramebuffer h = {}; + const VkResult r = vkCreateFramebuffer(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyFramebuffer}, framebuffer); + } + + VkResult createImage(const Device& device, + const VkImageCreateInfo& createInfo, + Image& image) const noexcept + { + VkImage h = {}; + const VkResult r = vkCreateImage(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyImage}, image); + } + + VkResult createImageView(const Device& device, + const VkImageViewCreateInfo& createInfo, + ImageView& imageView) const noexcept + { + VkImageView h = {}; + const VkResult r = vkCreateImageView(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyImageView}, imageView); + } + + template<size_t count> + VkResult createGraphicsPipelines( + const Device& device, + const OptionalParameter<PipelineCache>& pipelineCache, + const std::array<VkGraphicsPipelineCreateInfo, count>& createInfos, + std::array<Pipeline, count>& pipelines) const noexcept + { + std::array<VkPipeline, count> pipelineHandles{}; + + if (const VkResult r = + vkCreateGraphicsPipelines(device, + pipelineCache.get(), + static_cast<uint32_t>(createInfos.size()), + createInfos.data(), + nullptr, + pipelineHandles.data())) { + return r; + } + + pipelines = make_handle_array<Pipeline>( + device.get(), vkDestroyPipeline, pipelineHandles); + return VK_SUCCESS; + } + + VkResult createPipelineCache(const Device& device, + const VkPipelineCacheCreateInfo& createInfo, + PipelineCache& pipelineCache) const noexcept + { + VkPipelineCache h = {}; + const VkResult r = vkCreatePipelineCache(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyPipelineCache}, pipelineCache); + } + + VkResult createPipelineLayout(const Device& device, + const VkPipelineLayoutCreateInfo& createInfo, + PipelineLayout& pipelineLayout) const noexcept + { + VkPipelineLayout h = {}; + const VkResult r = vkCreatePipelineLayout(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyPipelineLayout}, pipelineLayout); + } + + VkResult createQueryPool(const Device& device, + const VkQueryPoolCreateInfo& createInfo, + QueryPool& queryPool) const noexcept + { + VkQueryPool h = {}; + const VkResult r = vkCreateQueryPool(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyQueryPool}, queryPool); + } + + VkResult createRenderPass(const Device& device, + const VkRenderPassCreateInfo& createInfo, + RenderPass& renderPass) const noexcept + { + VkRenderPass h = {}; + const VkResult r = vkCreateRenderPass(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyRenderPass}, renderPass); + } + + VkResult createSampler(const Device& device, + const VkSamplerCreateInfo& createInfo, + Sampler& sampler) const noexcept + { + VkSampler h = {}; + const VkResult r = vkCreateSampler(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroySampler}, sampler); + } + + VkResult createSemaphore(const Device& device, + const VkSemaphoreCreateInfo& createInfo, + Semaphore& semaphore) const noexcept + { + VkSemaphore h = {}; + const VkResult r = vkCreateSemaphore(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroySemaphore}, semaphore); + } + + VkResult createShaderModule(const Device& device, + const VkShaderModuleCreateInfo& createInfo, + ShaderModule& shaderModule) const noexcept + { + VkShaderModule h = {}; + const VkResult r = vkCreateShaderModule(device, &createInfo, nullptr, &h); + + return wrapResult(r, h, {device, vkDestroyShaderModule}, shaderModule); + } + + VkResult deviceWaitIdle(const Device& device) const noexcept + { + return vkDeviceWaitIdle(device); + } + + template<class Vector> + VkResult enumerateDeviceExtensionProperties( + const PhysicalDevice& physicalDevice, + const char* const layerName, + Vector& properties) const noexcept + { + return detail::wrapVectorAccessor<VkExtensionProperties>( + properties, + vkEnumerateDeviceExtensionProperties, + physicalDevice, + layerName); + } + + template<class Vector> + VkResult enumerateDeviceExtensionProperties( + const PhysicalDevice& physicalDevice, + Vector& properties) const noexcept + { + return detail::wrapVectorAccessor<VkExtensionProperties>( + properties, + vkEnumerateDeviceExtensionProperties, + physicalDevice, + nullptr); + } + + template<class Vector> + VkResult enumeratePhysicalDevices(const Instance& instance, + Vector& physicalDevices) const noexcept + { + uint32_t count = 0u; + VkResult r = vkEnumeratePhysicalDevices(instance, &count, nullptr); + if (r > VK_INCOMPLETE) { + return r; + } + + physicalDevices = Vector(count); + if ((r = vkEnumeratePhysicalDevices( + instance, &count, physicalDevices.data()))) { + return r; + } + + return VK_SUCCESS; + } + + sk::Queue getDeviceQueue(const Device& device, + const uint32_t queueFamilyIndex, + const uint32_t queueIndex) const noexcept + { + VkQueue queue{}; + vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, &queue); + return sk::Queue{queue}; + } + + VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice) const noexcept + { + VkPhysicalDeviceMemoryProperties properties{}; + vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties); + return properties; + } + + VkPhysicalDeviceProperties getPhysicalDeviceProperties( + const PhysicalDevice& physicalDevice) const noexcept + { + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(physicalDevice, &properties); + return properties; + } + + template<class Vector> + VkResult getPhysicalDeviceQueueFamilyProperties( + const PhysicalDevice& physicalDevice, + Vector& queueFamilyProperties) const noexcept + { + uint32_t count = 0u; + vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, nullptr); + + queueFamilyProperties = Vector(count); + vkGetPhysicalDeviceQueueFamilyProperties( + physicalDevice, &count, queueFamilyProperties.data()); + + return VK_SUCCESS; + } + + VkMemoryRequirements getBufferMemoryRequirements( + const Device& device, + const Buffer& buffer) const noexcept + { + VkMemoryRequirements requirements; + vkGetBufferMemoryRequirements(device, buffer, &requirements); + return requirements; + } + + VkResult allocateMemory(const Device& device, + const VkMemoryAllocateInfo& info, + DeviceMemory& memory) const noexcept + { + VkDeviceMemory h = {}; + if (const VkResult r = vkAllocateMemory(device, &info, nullptr, &h)) { + return r; + } else if (!h) { + return VK_ERROR_OUT_OF_DEVICE_MEMORY; + } + + memory = DeviceMemory{h, {device, vkFreeMemory}}; + return VK_SUCCESS; + } + + VkResult mapMemory(const Device& device, + const DeviceMemory& memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + MappedMemory& mappedMemory) const noexcept + { + void* data = nullptr; + if (const VkResult r = + vkMapMemory(device, memory, offset, size, flags, &data)) { + return r; + } + + mappedMemory = MappedMemory{*this, device, memory, data}; + return VK_SUCCESS; + } + + VkResult queueSubmit(const Queue& queue, + uint32_t submitCount, + const VkSubmitInfo& submits, + const Fence& fence) const noexcept + { + return vkQueueSubmit(queue, submitCount, &submits, fence); + } + + VkResult queueSubmit(const Queue& queue, + const VkSubmitInfo& submit, + const Fence& fence) const noexcept + { + return vkQueueSubmit(queue, 1u, &submit, fence); + } + + template<size_t descriptorWriteCount, size_t descriptorCopyCount> + void updateDescriptorSets( + const Device& device, + std::array<VkWriteDescriptorSet, descriptorWriteCount> descriptorWrites, + std::array<VkCopyDescriptorSet, descriptorCopyCount> descriptorCopies) + const noexcept + { + vkUpdateDescriptorSets(device, + static_cast<uint32_t>(descriptorWrites.size()), + descriptorWrites.data(), + static_cast<uint32_t>(descriptorCopies.size()), + descriptorCopies.data()); + } + + VkResult resetFence(const Device& device, const Fence& fence) const noexcept + { + VkFence h = fence; + return vkResetFences(device, 1u, &h); + } + + VkResult waitForFence(const Device& device, + const Fence& fence, + uint64_t timeout) const noexcept + { + VkFence h = fence; + return vkWaitForFences(device, 1u, &h, VK_TRUE, timeout); + } + + VkResult waitForFence(const Device& device, const Fence& fence) const noexcept + { + VkFence h = fence; + return vkWaitForFences(device, 1u, &h, VK_TRUE, UINT64_MAX); + } + + // Scoped command buffer interface + SYBOK_NODISCARD + CommandScope beginCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferBeginInfo beginInfo) const noexcept; + + // VK_EXT_debug_report + + VkResult createDebugReportCallbackEXT( + const Instance& instance, + const VkDebugReportCallbackCreateInfoEXT& createInfo, + DebugReportCallbackEXT& callback) const noexcept + { + VkDebugReportCallbackEXT h = {}; + + if (const VkResult r = + vkCreateDebugReportCallbackEXT(instance, &createInfo, nullptr, &h)) { + return r; + } else if (!h) { + return VK_ERROR_FEATURE_NOT_PRESENT; + } + + callback = {h, {instance, vkDestroyDebugReportCallbackEXT}}; + return VK_SUCCESS; + } + + // VK_KHR_surface + + VkResult getPhysicalDeviceSurfaceCapabilitiesKHR( + const PhysicalDevice& physicalDevice, + const SurfaceKHR& surface, + VkSurfaceCapabilitiesKHR& capabilities) const noexcept + { + return vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + physicalDevice, surface, &capabilities); + } + + template<typename Vector> + VkResult getPhysicalDeviceSurfaceFormatsKHR( + const PhysicalDevice& physicalDevice, + const SurfaceKHR& surface, + Vector& surfaceFormats) const noexcept + { + return detail::wrapVectorAccessor<VkSurfaceFormatKHR>( + surfaceFormats, + vkGetPhysicalDeviceSurfaceFormatsKHR, + physicalDevice, + surface.get()); + } + + template<typename Vector> + VkResult getPhysicalDeviceSurfacePresentModesKHR( + const PhysicalDevice& physicalDevice, + const SurfaceKHR& surface, + Vector& presentModes) const noexcept + { + return detail::wrapVectorAccessor<VkPresentModeKHR>( + presentModes, + vkGetPhysicalDeviceSurfacePresentModesKHR, + physicalDevice, + surface.get()); + } + + VkResult getPhysicalDeviceSurfaceSupportKHR( + const PhysicalDevice& physicalDevice, + uint32_t queueFamilyIndex, + const SurfaceKHR& surface, + bool& supported) const noexcept + { + VkBool32 s = {}; + + if (VkResult r = vkGetPhysicalDeviceSurfaceSupportKHR( + physicalDevice, queueFamilyIndex, surface, &s)) { + return r; + } + + supported = s; + return VK_SUCCESS; + } + + // VK_KHR_swapchain + + VkResult acquireNextImageKHR(const Device& device, + const SwapchainKHR& swapchain, + uint64_t timeout, + const Semaphore& semaphore, + const OptionalParameter<Fence>& fence, + uint32_t* pImageIndex) const noexcept + { + return vkAcquireNextImageKHR( + device, swapchain, timeout, semaphore, fence.get(), pImageIndex); + } + + template<class Vector> + VkResult getSwapchainImagesKHR(const Device& device, + const SwapchainKHR& swapchain, + Vector& images) const noexcept + { + return detail::wrapVectorAccessor<VkImage>( + images, vkGetSwapchainImagesKHR, device.get(), swapchain.get()); + } + + VkResult createSwapchainKHR(const Device& device, + const VkSwapchainCreateInfoKHR& createInfo, + SwapchainKHR& swapchain) const noexcept + { + VkSwapchainKHR h = {}; + const VkResult r = vkCreateSwapchainKHR(device, &createInfo, nullptr, &h); + + if (r) { + return r; + } else if (!h) { + return VK_ERROR_INCOMPATIBLE_DRIVER; + } + + swapchain = {h, {device, vkDestroySwapchainKHR}}; + return VK_SUCCESS; + } + + VkResult queuePresentKHR(const Queue& queue, + const VkPresentInfoKHR& presentInfo) const noexcept + { + return vkQueuePresentKHR(queue, &presentInfo); + } #define SK_FUNC(name) \ - PFN_##name name {} // NOLINT - - // Vulkan 1.0 Core - SK_FUNC(vkAllocateCommandBuffers); - SK_FUNC(vkAllocateDescriptorSets); - SK_FUNC(vkAllocateMemory); - SK_FUNC(vkBeginCommandBuffer); - SK_FUNC(vkBindBufferMemory); - SK_FUNC(vkBindImageMemory); - SK_FUNC(vkCmdBeginQuery); - SK_FUNC(vkCmdBeginRenderPass); - SK_FUNC(vkCmdBindDescriptorSets); - SK_FUNC(vkCmdBindIndexBuffer); - SK_FUNC(vkCmdBindPipeline); - SK_FUNC(vkCmdBindVertexBuffers); - SK_FUNC(vkCmdBlitImage); - SK_FUNC(vkCmdClearAttachments); - SK_FUNC(vkCmdClearColorImage); - SK_FUNC(vkCmdClearDepthStencilImage); - SK_FUNC(vkCmdCopyBuffer); - SK_FUNC(vkCmdCopyBufferToImage); - SK_FUNC(vkCmdCopyImage); - SK_FUNC(vkCmdCopyImageToBuffer); - SK_FUNC(vkCmdCopyQueryPoolResults); - SK_FUNC(vkCmdDispatch); - SK_FUNC(vkCmdDispatchIndirect); - SK_FUNC(vkCmdDraw); - SK_FUNC(vkCmdDrawIndexed); - SK_FUNC(vkCmdDrawIndexedIndirect); - SK_FUNC(vkCmdDrawIndirect); - SK_FUNC(vkCmdEndQuery); - SK_FUNC(vkCmdEndRenderPass); - SK_FUNC(vkCmdExecuteCommands); - SK_FUNC(vkCmdFillBuffer); - SK_FUNC(vkCmdNextSubpass); - SK_FUNC(vkCmdPipelineBarrier); - SK_FUNC(vkCmdPushConstants); - SK_FUNC(vkCmdResetEvent); - SK_FUNC(vkCmdResetQueryPool); - SK_FUNC(vkCmdResolveImage); - SK_FUNC(vkCmdSetBlendConstants); - SK_FUNC(vkCmdSetDepthBias); - SK_FUNC(vkCmdSetDepthBounds); - SK_FUNC(vkCmdSetEvent); - SK_FUNC(vkCmdSetLineWidth); - SK_FUNC(vkCmdSetScissor); - SK_FUNC(vkCmdSetStencilCompareMask); - SK_FUNC(vkCmdSetStencilReference); - SK_FUNC(vkCmdSetStencilWriteMask); - SK_FUNC(vkCmdSetViewport); - SK_FUNC(vkCmdUpdateBuffer); - SK_FUNC(vkCmdWaitEvents); - SK_FUNC(vkCmdWriteTimestamp); - SK_FUNC(vkCreateBuffer); - SK_FUNC(vkCreateBufferView); - SK_FUNC(vkCreateCommandPool); - SK_FUNC(vkCreateComputePipelines); - SK_FUNC(vkCreateDescriptorPool); - SK_FUNC(vkCreateDescriptorSetLayout); - SK_FUNC(vkCreateDevice); - SK_FUNC(vkCreateEvent); - SK_FUNC(vkCreateFence); - SK_FUNC(vkCreateFramebuffer); - SK_FUNC(vkCreateGraphicsPipelines); - SK_FUNC(vkCreateImage); - SK_FUNC(vkCreateImageView); - SK_FUNC(vkCreateInstance); - SK_FUNC(vkCreatePipelineCache); - SK_FUNC(vkCreatePipelineLayout); - SK_FUNC(vkCreateQueryPool); - SK_FUNC(vkCreateRenderPass); - SK_FUNC(vkCreateSampler); - SK_FUNC(vkCreateSemaphore); - SK_FUNC(vkCreateShaderModule); - SK_FUNC(vkDestroyBuffer); - SK_FUNC(vkDestroyBufferView); - SK_FUNC(vkDestroyCommandPool); - SK_FUNC(vkDestroyDescriptorPool); - SK_FUNC(vkDestroyDescriptorSetLayout); - SK_FUNC(vkDestroyDevice); - SK_FUNC(vkDestroyEvent); - SK_FUNC(vkDestroyFence); - SK_FUNC(vkDestroyFramebuffer); - SK_FUNC(vkDestroyImage); - SK_FUNC(vkDestroyImageView); - SK_FUNC(vkDestroyPipeline); - SK_FUNC(vkDestroyPipelineCache); - SK_FUNC(vkDestroyPipelineLayout); - SK_FUNC(vkDestroyQueryPool); - SK_FUNC(vkDestroyRenderPass); - SK_FUNC(vkDestroySampler); - SK_FUNC(vkDestroySemaphore); - SK_FUNC(vkDestroyShaderModule); - SK_FUNC(vkDeviceWaitIdle); - SK_FUNC(vkEndCommandBuffer); - SK_FUNC(vkEnumerateDeviceExtensionProperties); - SK_FUNC(vkEnumerateDeviceLayerProperties); - SK_FUNC(vkEnumeratePhysicalDevices); - SK_FUNC(vkFlushMappedMemoryRanges); - SK_FUNC(vkFreeCommandBuffers); - SK_FUNC(vkFreeDescriptorSets); - SK_FUNC(vkFreeMemory); - SK_FUNC(vkGetBufferMemoryRequirements); - SK_FUNC(vkGetDeviceMemoryCommitment); - SK_FUNC(vkGetDeviceProcAddr); - SK_FUNC(vkGetDeviceQueue); - SK_FUNC(vkGetEventStatus); - SK_FUNC(vkGetFenceStatus); - SK_FUNC(vkGetImageMemoryRequirements); - SK_FUNC(vkGetImageSparseMemoryRequirements); - SK_FUNC(vkGetImageSubresourceLayout); - SK_FUNC(vkGetInstanceProcAddr); - SK_FUNC(vkGetPhysicalDeviceFeatures); - SK_FUNC(vkGetPhysicalDeviceFormatProperties); - SK_FUNC(vkGetPhysicalDeviceImageFormatProperties); - SK_FUNC(vkGetPhysicalDeviceMemoryProperties); - SK_FUNC(vkGetPhysicalDeviceProperties); - SK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties); - SK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties); - SK_FUNC(vkGetPipelineCacheData); - SK_FUNC(vkGetQueryPoolResults); - SK_FUNC(vkGetRenderAreaGranularity); - SK_FUNC(vkInvalidateMappedMemoryRanges); - SK_FUNC(vkMapMemory); - SK_FUNC(vkMergePipelineCaches); - SK_FUNC(vkQueueBindSparse); - SK_FUNC(vkQueueSubmit); - SK_FUNC(vkQueueWaitIdle); - SK_FUNC(vkResetCommandBuffer); - SK_FUNC(vkResetCommandPool); - SK_FUNC(vkResetDescriptorPool); - SK_FUNC(vkResetEvent); - SK_FUNC(vkResetFences); - SK_FUNC(vkSetEvent); - SK_FUNC(vkUnmapMemory); - SK_FUNC(vkUpdateDescriptorSets); - SK_FUNC(vkWaitForFences); - - // VK_EXT_debug_report - SK_FUNC(vkCreateDebugReportCallbackEXT); - SK_FUNC(vkDebugReportMessageEXT); - SK_FUNC(vkDestroyDebugReportCallbackEXT); - - // VK_KHR_surface - SK_FUNC(vkDestroySurfaceKHR); - SK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); - SK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR); - SK_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR); - SK_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR); - - // VK_KHR_swapchain - SK_FUNC(vkAcquireNextImageKHR); - SK_FUNC(vkCreateSwapchainKHR); - SK_FUNC(vkDestroySwapchainKHR); - SK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR); - SK_FUNC(vkGetDeviceGroupSurfacePresentModesKHR); - SK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR); - SK_FUNC(vkGetSwapchainImagesKHR); - SK_FUNC(vkQueuePresentKHR); + PFN_##name name {} // NOLINT + + // Vulkan 1.0 Core + SK_FUNC(vkAllocateCommandBuffers); + SK_FUNC(vkAllocateDescriptorSets); + SK_FUNC(vkAllocateMemory); + SK_FUNC(vkBeginCommandBuffer); + SK_FUNC(vkBindBufferMemory); + SK_FUNC(vkBindImageMemory); + SK_FUNC(vkCmdBeginQuery); + SK_FUNC(vkCmdBeginRenderPass); + SK_FUNC(vkCmdBindDescriptorSets); + SK_FUNC(vkCmdBindIndexBuffer); + SK_FUNC(vkCmdBindPipeline); + SK_FUNC(vkCmdBindVertexBuffers); + SK_FUNC(vkCmdBlitImage); + SK_FUNC(vkCmdClearAttachments); + SK_FUNC(vkCmdClearColorImage); + SK_FUNC(vkCmdClearDepthStencilImage); + SK_FUNC(vkCmdCopyBuffer); + SK_FUNC(vkCmdCopyBufferToImage); + SK_FUNC(vkCmdCopyImage); + SK_FUNC(vkCmdCopyImageToBuffer); + SK_FUNC(vkCmdCopyQueryPoolResults); + SK_FUNC(vkCmdDispatch); + SK_FUNC(vkCmdDispatchIndirect); + SK_FUNC(vkCmdDraw); + SK_FUNC(vkCmdDrawIndexed); + SK_FUNC(vkCmdDrawIndexedIndirect); + SK_FUNC(vkCmdDrawIndirect); + SK_FUNC(vkCmdEndQuery); + SK_FUNC(vkCmdEndRenderPass); + SK_FUNC(vkCmdExecuteCommands); + SK_FUNC(vkCmdFillBuffer); + SK_FUNC(vkCmdNextSubpass); + SK_FUNC(vkCmdPipelineBarrier); + SK_FUNC(vkCmdPushConstants); + SK_FUNC(vkCmdResetEvent); + SK_FUNC(vkCmdResetQueryPool); + SK_FUNC(vkCmdResolveImage); + SK_FUNC(vkCmdSetBlendConstants); + SK_FUNC(vkCmdSetDepthBias); + SK_FUNC(vkCmdSetDepthBounds); + SK_FUNC(vkCmdSetEvent); + SK_FUNC(vkCmdSetLineWidth); + SK_FUNC(vkCmdSetScissor); + SK_FUNC(vkCmdSetStencilCompareMask); + SK_FUNC(vkCmdSetStencilReference); + SK_FUNC(vkCmdSetStencilWriteMask); + SK_FUNC(vkCmdSetViewport); + SK_FUNC(vkCmdUpdateBuffer); + SK_FUNC(vkCmdWaitEvents); + SK_FUNC(vkCmdWriteTimestamp); + SK_FUNC(vkCreateBuffer); + SK_FUNC(vkCreateBufferView); + SK_FUNC(vkCreateCommandPool); + SK_FUNC(vkCreateComputePipelines); + SK_FUNC(vkCreateDescriptorPool); + SK_FUNC(vkCreateDescriptorSetLayout); + SK_FUNC(vkCreateDevice); + SK_FUNC(vkCreateEvent); + SK_FUNC(vkCreateFence); + SK_FUNC(vkCreateFramebuffer); + SK_FUNC(vkCreateGraphicsPipelines); + SK_FUNC(vkCreateImage); + SK_FUNC(vkCreateImageView); + SK_FUNC(vkCreateInstance); + SK_FUNC(vkCreatePipelineCache); + SK_FUNC(vkCreatePipelineLayout); + SK_FUNC(vkCreateQueryPool); + SK_FUNC(vkCreateRenderPass); + SK_FUNC(vkCreateSampler); + SK_FUNC(vkCreateSemaphore); + SK_FUNC(vkCreateShaderModule); + SK_FUNC(vkDestroyBuffer); + SK_FUNC(vkDestroyBufferView); + SK_FUNC(vkDestroyCommandPool); + SK_FUNC(vkDestroyDescriptorPool); + SK_FUNC(vkDestroyDescriptorSetLayout); + SK_FUNC(vkDestroyDevice); + SK_FUNC(vkDestroyEvent); + SK_FUNC(vkDestroyFence); + SK_FUNC(vkDestroyFramebuffer); + SK_FUNC(vkDestroyImage); + SK_FUNC(vkDestroyImageView); + SK_FUNC(vkDestroyPipeline); + SK_FUNC(vkDestroyPipelineCache); + SK_FUNC(vkDestroyPipelineLayout); + SK_FUNC(vkDestroyQueryPool); + SK_FUNC(vkDestroyRenderPass); + SK_FUNC(vkDestroySampler); + SK_FUNC(vkDestroySemaphore); + SK_FUNC(vkDestroyShaderModule); + SK_FUNC(vkDeviceWaitIdle); + SK_FUNC(vkEndCommandBuffer); + SK_FUNC(vkEnumerateDeviceExtensionProperties); + SK_FUNC(vkEnumerateDeviceLayerProperties); + SK_FUNC(vkEnumeratePhysicalDevices); + SK_FUNC(vkFlushMappedMemoryRanges); + SK_FUNC(vkFreeCommandBuffers); + SK_FUNC(vkFreeDescriptorSets); + SK_FUNC(vkFreeMemory); + SK_FUNC(vkGetBufferMemoryRequirements); + SK_FUNC(vkGetDeviceMemoryCommitment); + SK_FUNC(vkGetDeviceProcAddr); + SK_FUNC(vkGetDeviceQueue); + SK_FUNC(vkGetEventStatus); + SK_FUNC(vkGetFenceStatus); + SK_FUNC(vkGetImageMemoryRequirements); + SK_FUNC(vkGetImageSparseMemoryRequirements); + SK_FUNC(vkGetImageSubresourceLayout); + SK_FUNC(vkGetInstanceProcAddr); + SK_FUNC(vkGetPhysicalDeviceFeatures); + SK_FUNC(vkGetPhysicalDeviceFormatProperties); + SK_FUNC(vkGetPhysicalDeviceImageFormatProperties); + SK_FUNC(vkGetPhysicalDeviceMemoryProperties); + SK_FUNC(vkGetPhysicalDeviceProperties); + SK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties); + SK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties); + SK_FUNC(vkGetPipelineCacheData); + SK_FUNC(vkGetQueryPoolResults); + SK_FUNC(vkGetRenderAreaGranularity); + SK_FUNC(vkInvalidateMappedMemoryRanges); + SK_FUNC(vkMapMemory); + SK_FUNC(vkMergePipelineCaches); + SK_FUNC(vkQueueBindSparse); + SK_FUNC(vkQueueSubmit); + SK_FUNC(vkQueueWaitIdle); + SK_FUNC(vkResetCommandBuffer); + SK_FUNC(vkResetCommandPool); + SK_FUNC(vkResetDescriptorPool); + SK_FUNC(vkResetEvent); + SK_FUNC(vkResetFences); + SK_FUNC(vkSetEvent); + SK_FUNC(vkUnmapMemory); + SK_FUNC(vkUpdateDescriptorSets); + SK_FUNC(vkWaitForFences); + + // VK_EXT_debug_report + SK_FUNC(vkCreateDebugReportCallbackEXT); + SK_FUNC(vkDebugReportMessageEXT); + SK_FUNC(vkDestroyDebugReportCallbackEXT); + + // VK_KHR_surface + SK_FUNC(vkDestroySurfaceKHR); + SK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + SK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR); + SK_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR); + SK_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR); + + // VK_KHR_swapchain + SK_FUNC(vkAcquireNextImageKHR); + SK_FUNC(vkCreateSwapchainKHR); + SK_FUNC(vkDestroySwapchainKHR); + SK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR); + SK_FUNC(vkGetDeviceGroupSurfacePresentModesKHR); + SK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR); + SK_FUNC(vkGetSwapchainImagesKHR); + SK_FUNC(vkQueuePresentKHR); #undef SK_FUNC private: - template<class T> - static inline VkResult wrapResult(const VkResult r, - const typename T::Handle handle, - typename T::Deleter&& deleter, - T& result) noexcept - { - if (r) { - return r; - } else if (!handle) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - result = T{handle, std::move(deleter)}; - return VK_SUCCESS; - } + template<class T> + static inline VkResult wrapResult(const VkResult r, + const typename T::Handle handle, + typename T::Deleter&& deleter, + T& result) noexcept + { + if (r) { + return r; + } else if (!handle) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + result = T{handle, std::move(deleter)}; + return VK_SUCCESS; + } }; /// Scope for commands that work both inside and outside a render pass class CommonCommandScope { public: - CommonCommandScope(const VulkanApi& api, - VkCommandBuffer commandBuffer, - VkResult result) noexcept - : _api{api} - , _commandBuffer{commandBuffer} - , _result{result} - {} - - CommonCommandScope(const CommonCommandScope&) noexcept = delete; - CommonCommandScope& operator=(const CommonCommandScope&) noexcept = delete; - - CommonCommandScope(CommonCommandScope&& scope) noexcept - : _api{scope._api} - , _commandBuffer{scope._commandBuffer} - { - scope._commandBuffer = {}; - } - - CommonCommandScope& operator=(CommonCommandScope&&) = delete; - - ~CommonCommandScope() noexcept = default; - - explicit operator bool() const noexcept { return _result == VK_SUCCESS; } - - VkResult error() const noexcept { return _result; } - - void bindPipeline(VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) const noexcept - { - _api.vkCmdBindPipeline(_commandBuffer, pipelineBindPoint, pipeline); - } - - void setViewport(uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports) const noexcept - { - _api.vkCmdSetViewport(_commandBuffer, - firstViewport, - viewportCount, - pViewports); - } - - void setScissor(uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors) const noexcept - { - _api.vkCmdSetScissor(_commandBuffer, - firstScissor, - scissorCount, - pScissors); - } - - void setLineWidth(float lineWidth) const noexcept - { - _api.vkCmdSetLineWidth(_commandBuffer, lineWidth); - } - - void setDepthBias(float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor) const noexcept - { - _api.vkCmdSetDepthBias(_commandBuffer, - depthBiasConstantFactor, - depthBiasClamp, - depthBiasSlopeFactor); - } - - void setBlendConstants(const float blendConstants[4]) const noexcept - { - _api.vkCmdSetBlendConstants(_commandBuffer, blendConstants); - } - - void - setDepthBounds(float minDepthBounds, float maxDepthBounds) const noexcept - { - _api.vkCmdSetDepthBounds(_commandBuffer, - minDepthBounds, - maxDepthBounds); - } - - void setStencilCompareMask(VkStencilFaceFlags faceMask, - uint32_t compareMask) const noexcept - { - _api.vkCmdSetStencilCompareMask(_commandBuffer, faceMask, compareMask); - } - - void setStencilWriteMask(VkStencilFaceFlags faceMask, - uint32_t writeMask) const noexcept - { - _api.vkCmdSetStencilWriteMask(_commandBuffer, faceMask, writeMask); - } - - void setStencilReference(VkStencilFaceFlags faceMask, - uint32_t reference) const noexcept - { - _api.vkCmdSetStencilReference(_commandBuffer, faceMask, reference); - } - - void bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets) const noexcept - { - _api.vkCmdBindDescriptorSets(_commandBuffer, - pipelineBindPoint, - layout, - firstSet, - descriptorSetCount, - pDescriptorSets, - dynamicOffsetCount, - pDynamicOffsets); - } - - void bindIndexBuffer(VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType) const noexcept - { - _api.vkCmdBindIndexBuffer(_commandBuffer, buffer, offset, indexType); - } - - void bindVertexBuffers(uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets) const noexcept - { - _api.vkCmdBindVertexBuffers( - _commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); - } - - void - waitEvents(uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept - { - _api.vkCmdWaitEvents(_commandBuffer, - eventCount, - pEvents, - srcStageMask, - dstStageMask, - memoryBarrierCount, - pMemoryBarriers, - bufferMemoryBarrierCount, - pBufferMemoryBarriers, - imageMemoryBarrierCount, - pImageMemoryBarriers); - } - - void pipelineBarrier( - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept - { - _api.vkCmdPipelineBarrier(_commandBuffer, - srcStageMask, - dstStageMask, - dependencyFlags, - memoryBarrierCount, - pMemoryBarriers, - bufferMemoryBarrierCount, - pBufferMemoryBarriers, - imageMemoryBarrierCount, - pImageMemoryBarriers); - } - - void beginQuery(VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags) const noexcept - { - _api.vkCmdBeginQuery(_commandBuffer, queryPool, query, flags); - } - - void endQuery(VkQueryPool queryPool, uint32_t query) const noexcept - { - _api.vkCmdEndQuery(_commandBuffer, queryPool, query); - } - - void writeTimestamp(VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query) const noexcept - { - _api.vkCmdWriteTimestamp(_commandBuffer, - pipelineStage, - queryPool, - query); - } - - void pushConstants(VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues) const noexcept - { - _api.vkCmdPushConstants( - _commandBuffer, layout, stageFlags, offset, size, pValues); - } - - void executeCommands(uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) const noexcept - { - _api.vkCmdExecuteCommands(_commandBuffer, - commandBufferCount, - pCommandBuffers); - } + CommonCommandScope(const VulkanApi& api, + VkCommandBuffer commandBuffer, + VkResult result) noexcept + : _api{api} + , _commandBuffer{commandBuffer} + , _result{result} + {} + + CommonCommandScope(const CommonCommandScope&) noexcept = delete; + CommonCommandScope& operator=(const CommonCommandScope&) noexcept = delete; + + CommonCommandScope(CommonCommandScope&& scope) noexcept + : _api{scope._api} + , _commandBuffer{scope._commandBuffer} + { + scope._commandBuffer = {}; + } + + CommonCommandScope& operator=(CommonCommandScope&&) = delete; + + ~CommonCommandScope() noexcept = default; + + explicit operator bool() const noexcept { return _result == VK_SUCCESS; } + + VkResult error() const noexcept { return _result; } + + void bindPipeline(VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) const noexcept + { + _api.vkCmdBindPipeline(_commandBuffer, pipelineBindPoint, pipeline); + } + + void setViewport(uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports) const noexcept + { + _api.vkCmdSetViewport( + _commandBuffer, firstViewport, viewportCount, pViewports); + } + + void setScissor(uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors) const noexcept + { + _api.vkCmdSetScissor(_commandBuffer, firstScissor, scissorCount, pScissors); + } + + void setLineWidth(float lineWidth) const noexcept + { + _api.vkCmdSetLineWidth(_commandBuffer, lineWidth); + } + + void setDepthBias(float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor) const noexcept + { + _api.vkCmdSetDepthBias(_commandBuffer, + depthBiasConstantFactor, + depthBiasClamp, + depthBiasSlopeFactor); + } + + void setBlendConstants(const float blendConstants[4]) const noexcept + { + _api.vkCmdSetBlendConstants(_commandBuffer, blendConstants); + } + + void setDepthBounds(float minDepthBounds, float maxDepthBounds) const noexcept + { + _api.vkCmdSetDepthBounds(_commandBuffer, minDepthBounds, maxDepthBounds); + } + + void setStencilCompareMask(VkStencilFaceFlags faceMask, + uint32_t compareMask) const noexcept + { + _api.vkCmdSetStencilCompareMask(_commandBuffer, faceMask, compareMask); + } + + void setStencilWriteMask(VkStencilFaceFlags faceMask, + uint32_t writeMask) const noexcept + { + _api.vkCmdSetStencilWriteMask(_commandBuffer, faceMask, writeMask); + } + + void setStencilReference(VkStencilFaceFlags faceMask, + uint32_t reference) const noexcept + { + _api.vkCmdSetStencilReference(_commandBuffer, faceMask, reference); + } + + void bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) const noexcept + { + _api.vkCmdBindDescriptorSets(_commandBuffer, + pipelineBindPoint, + layout, + firstSet, + descriptorSetCount, + pDescriptorSets, + dynamicOffsetCount, + pDynamicOffsets); + } + + void bindIndexBuffer(VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType) const noexcept + { + _api.vkCmdBindIndexBuffer(_commandBuffer, buffer, offset, indexType); + } + + void bindVertexBuffers(uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets) const noexcept + { + _api.vkCmdBindVertexBuffers( + _commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + } + + void waitEvents( + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept + { + _api.vkCmdWaitEvents(_commandBuffer, + eventCount, + pEvents, + srcStageMask, + dstStageMask, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers); + } + + void pipelineBarrier( + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept + { + _api.vkCmdPipelineBarrier(_commandBuffer, + srcStageMask, + dstStageMask, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers); + } + + void beginQuery(VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags) const noexcept + { + _api.vkCmdBeginQuery(_commandBuffer, queryPool, query, flags); + } + + void endQuery(VkQueryPool queryPool, uint32_t query) const noexcept + { + _api.vkCmdEndQuery(_commandBuffer, queryPool, query); + } + + void writeTimestamp(VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query) const noexcept + { + _api.vkCmdWriteTimestamp(_commandBuffer, pipelineStage, queryPool, query); + } + + void pushConstants(VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues) const noexcept + { + _api.vkCmdPushConstants( + _commandBuffer, layout, stageFlags, offset, size, pValues); + } + + void executeCommands(uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) const noexcept + { + _api.vkCmdExecuteCommands( + _commandBuffer, commandBufferCount, pCommandBuffers); + } protected: - const VulkanApi& _api; - VkCommandBuffer _commandBuffer; - VkResult _result; + const VulkanApi& _api; + VkCommandBuffer _commandBuffer; + VkResult _result; }; // Top level command scope outside a render pass class CommandScope : public CommonCommandScope { public: - CommandScope(const VulkanApi& api, - VkCommandBuffer commandBuffer, - VkResult result) noexcept - : CommonCommandScope{api, commandBuffer, result} - {} - - CommandScope(const CommandScope&) = delete; - CommandScope& operator=(const CommandScope&) = delete; - - CommandScope(CommandScope&& scope) noexcept - : CommonCommandScope{std::forward<CommandScope>(scope)} - {} - - CommandScope& operator=(CommandScope&&) = delete; - - ~CommandScope() noexcept - { - assert(!_commandBuffer); // Buffer must be finished with end() - } - - VkResult end() noexcept - { - if (_commandBuffer) { - VkResult r = _api.vkEndCommandBuffer(_commandBuffer); - _commandBuffer = {}; - return r; - } - - return VK_NOT_READY; - } - - void dispatch(uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) const noexcept - { - _api.vkCmdDispatch(_commandBuffer, - groupCountX, - groupCountY, - groupCountZ); - } - - void dispatchIndirect(VkBuffer buffer, VkDeviceSize offset) const noexcept - { - _api.vkCmdDispatchIndirect(_commandBuffer, buffer, offset); - } - - void copyBuffer(VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions) const noexcept - { - _api.vkCmdCopyBuffer( - _commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - } - - void copyImage(VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions) const noexcept - { - _api.vkCmdCopyImage(_commandBuffer, - srcImage, - srcImageLayout, - dstImage, - dstImageLayout, - regionCount, - pRegions); - } - - void blitImage(VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter) const noexcept - { - _api.vkCmdBlitImage(_commandBuffer, - srcImage, - srcImageLayout, - dstImage, - dstImageLayout, - regionCount, - pRegions, - filter); - } - - void copyBufferToImage(VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) const noexcept - { - _api.vkCmdCopyBufferToImage(_commandBuffer, - srcBuffer, - dstImage, - dstImageLayout, - regionCount, - pRegions); - } - - void copyImageToBuffer(VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) const noexcept - { - _api.vkCmdCopyImageToBuffer(_commandBuffer, - srcImage, - srcImageLayout, - dstBuffer, - regionCount, - pRegions); - } - - void updateBuffer(VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData) const noexcept - { - _api.vkCmdUpdateBuffer( - _commandBuffer, dstBuffer, dstOffset, dataSize, pData); - } - - void fillBuffer(VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data) const noexcept - { - _api.vkCmdFillBuffer(_commandBuffer, dstBuffer, dstOffset, size, data); - } - - void clearColorImage(VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue& color, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) const noexcept - { - _api.vkCmdClearColorImage( - _commandBuffer, image, imageLayout, &color, rangeCount, pRanges); - } - - void clearDepthStencilImage( - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue& depthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) const noexcept - { - _api.vkCmdClearDepthStencilImage(_commandBuffer, - image, - imageLayout, - &depthStencil, - rangeCount, - pRanges); - } - - void resolveImage(VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions) const noexcept - { - _api.vkCmdResolveImage(_commandBuffer, - srcImage, - srcImageLayout, - dstImage, - dstImageLayout, - regionCount, - pRegions); - } - - void setEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept - { - _api.vkCmdSetEvent(_commandBuffer, event, stageMask); - } - - void - resetEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept - { - _api.vkCmdResetEvent(_commandBuffer, event, stageMask); - } - - void resetQueryPool(VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) const noexcept - { - _api.vkCmdResetQueryPool(_commandBuffer, - queryPool, - firstQuery, - queryCount); - } - - void copyQueryPoolResults(VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags) const noexcept - { - _api.vkCmdCopyQueryPoolResults(_commandBuffer, - queryPool, - firstQuery, - queryCount, - dstBuffer, - dstOffset, - stride, - flags); - } - - SYBOK_NODISCARD - RenderCommandScope - beginRenderPass(const VkRenderPassBeginInfo& renderPassBegin, - VkSubpassContents contents) const noexcept; + CommandScope(const VulkanApi& api, + VkCommandBuffer commandBuffer, + VkResult result) noexcept + : CommonCommandScope{api, commandBuffer, result} + {} + + CommandScope(const CommandScope&) = delete; + CommandScope& operator=(const CommandScope&) = delete; + + CommandScope(CommandScope&& scope) noexcept + : CommonCommandScope{std::forward<CommandScope>(scope)} + {} + + CommandScope& operator=(CommandScope&&) = delete; + + ~CommandScope() noexcept + { + assert(!_commandBuffer); // Buffer must be finished with end() + } + + VkResult end() noexcept + { + if (_commandBuffer) { + VkResult r = _api.vkEndCommandBuffer(_commandBuffer); + _commandBuffer = {}; + return r; + } + + return VK_NOT_READY; + } + + void dispatch(uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { + _api.vkCmdDispatch(_commandBuffer, groupCountX, groupCountY, groupCountZ); + } + + void dispatchIndirect(VkBuffer buffer, VkDeviceSize offset) const noexcept + { + _api.vkCmdDispatchIndirect(_commandBuffer, buffer, offset); + } + + void copyBuffer(VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions) const noexcept + { + _api.vkCmdCopyBuffer( + _commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + } + + void copyImage(VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions) const noexcept + { + _api.vkCmdCopyImage(_commandBuffer, + srcImage, + srcImageLayout, + dstImage, + dstImageLayout, + regionCount, + pRegions); + } + + void blitImage(VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter) const noexcept + { + _api.vkCmdBlitImage(_commandBuffer, + srcImage, + srcImageLayout, + dstImage, + dstImageLayout, + regionCount, + pRegions, + filter); + } + + void copyBufferToImage(VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) const noexcept + { + _api.vkCmdCopyBufferToImage(_commandBuffer, + srcBuffer, + dstImage, + dstImageLayout, + regionCount, + pRegions); + } + + void copyImageToBuffer(VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) const noexcept + { + _api.vkCmdCopyImageToBuffer(_commandBuffer, + srcImage, + srcImageLayout, + dstBuffer, + regionCount, + pRegions); + } + + void updateBuffer(VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData) const noexcept + { + _api.vkCmdUpdateBuffer( + _commandBuffer, dstBuffer, dstOffset, dataSize, pData); + } + + void fillBuffer(VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data) const noexcept + { + _api.vkCmdFillBuffer(_commandBuffer, dstBuffer, dstOffset, size, data); + } + + void clearColorImage(VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue& color, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) const noexcept + { + _api.vkCmdClearColorImage( + _commandBuffer, image, imageLayout, &color, rangeCount, pRanges); + } + + void clearDepthStencilImage( + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue& depthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) const noexcept + { + _api.vkCmdClearDepthStencilImage( + _commandBuffer, image, imageLayout, &depthStencil, rangeCount, pRanges); + } + + void resolveImage(VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions) const noexcept + { + _api.vkCmdResolveImage(_commandBuffer, + srcImage, + srcImageLayout, + dstImage, + dstImageLayout, + regionCount, + pRegions); + } + + void setEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept + { + _api.vkCmdSetEvent(_commandBuffer, event, stageMask); + } + + void resetEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept + { + _api.vkCmdResetEvent(_commandBuffer, event, stageMask); + } + + void resetQueryPool(VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) const noexcept + { + _api.vkCmdResetQueryPool(_commandBuffer, queryPool, firstQuery, queryCount); + } + + void copyQueryPoolResults(VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags) const noexcept + { + _api.vkCmdCopyQueryPoolResults(_commandBuffer, + queryPool, + firstQuery, + queryCount, + dstBuffer, + dstOffset, + stride, + flags); + } + + SYBOK_NODISCARD + RenderCommandScope beginRenderPass( + const VkRenderPassBeginInfo& renderPassBegin, + VkSubpassContents contents) const noexcept; }; class RenderCommandScope : public CommonCommandScope { public: - RenderCommandScope(const VulkanApi& api, - VkCommandBuffer commandBuffer) noexcept - : CommonCommandScope{api, commandBuffer, VK_SUCCESS} - {} - - RenderCommandScope(const RenderCommandScope&) = delete; - RenderCommandScope& operator=(const RenderCommandScope&) = delete; - - RenderCommandScope(RenderCommandScope&& scope) noexcept - : CommonCommandScope{std::forward<RenderCommandScope>(scope)} - {} - - RenderCommandScope& operator=(RenderCommandScope&&) = delete; - - ~RenderCommandScope() noexcept { _api.vkCmdEndRenderPass(_commandBuffer); } - - void draw(uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance) const noexcept - { - _api.vkCmdDraw(_commandBuffer, - vertexCount, - instanceCount, - firstVertex, - firstInstance); - } - - void drawIndexed(uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) const noexcept - { - _api.vkCmdDrawIndexed(_commandBuffer, - indexCount, - instanceCount, - firstIndex, - vertexOffset, - firstInstance); - } - - void drawIndirect(VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) const noexcept - { - _api.vkCmdDrawIndirect( - _commandBuffer, buffer, offset, drawCount, stride); - } - - void drawIndexedIndirect(VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) const noexcept - { - _api.vkCmdDrawIndexedIndirect( - _commandBuffer, buffer, offset, drawCount, stride); - } - - void clearAttachments(uint32_t attachmentCount, - const VkClearAttachment& attachments, - uint32_t rectCount, - const VkClearRect* pRects) const noexcept - { - _api.vkCmdClearAttachments( - _commandBuffer, attachmentCount, &attachments, rectCount, pRects); - } - - void nextSubpass(VkSubpassContents contents) const noexcept - { - _api.vkCmdNextSubpass(_commandBuffer, contents); - } + RenderCommandScope(const VulkanApi& api, + VkCommandBuffer commandBuffer) noexcept + : CommonCommandScope{api, commandBuffer, VK_SUCCESS} + {} + + RenderCommandScope(const RenderCommandScope&) = delete; + RenderCommandScope& operator=(const RenderCommandScope&) = delete; + + RenderCommandScope(RenderCommandScope&& scope) noexcept + : CommonCommandScope{std::forward<RenderCommandScope>(scope)} + {} + + RenderCommandScope& operator=(RenderCommandScope&&) = delete; + + ~RenderCommandScope() noexcept { _api.vkCmdEndRenderPass(_commandBuffer); } + + void draw(uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) const noexcept + { + _api.vkCmdDraw( + _commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + } + + void drawIndexed(uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance) const noexcept + { + _api.vkCmdDrawIndexed(_commandBuffer, + indexCount, + instanceCount, + firstIndex, + vertexOffset, + firstInstance); + } + + void drawIndirect(VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { + _api.vkCmdDrawIndirect(_commandBuffer, buffer, offset, drawCount, stride); + } + + void drawIndexedIndirect(VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { + _api.vkCmdDrawIndexedIndirect( + _commandBuffer, buffer, offset, drawCount, stride); + } + + void clearAttachments(uint32_t attachmentCount, + const VkClearAttachment& attachments, + uint32_t rectCount, + const VkClearRect* pRects) const noexcept + { + _api.vkCmdClearAttachments( + _commandBuffer, attachmentCount, &attachments, rectCount, pRects); + } + + void nextSubpass(VkSubpassContents contents) const noexcept + { + _api.vkCmdNextSubpass(_commandBuffer, contents); + } }; CommandScope VulkanApi::beginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo beginInfo) const noexcept + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo beginInfo) const noexcept { - if (const VkResult r = vkBeginCommandBuffer(commandBuffer, &beginInfo)) { - return {*this, nullptr, r}; - } + if (const VkResult r = vkBeginCommandBuffer(commandBuffer, &beginInfo)) { + return {*this, nullptr, r}; + } - return {*this, commandBuffer, VK_SUCCESS}; + return {*this, commandBuffer, VK_SUCCESS}; } inline RenderCommandScope CommandScope::beginRenderPass(const VkRenderPassBeginInfo& renderPassBegin, VkSubpassContents contents) const noexcept { - _api.vkCmdBeginRenderPass(_commandBuffer, &renderPassBegin, contents); + _api.vkCmdBeginRenderPass(_commandBuffer, &renderPassBegin, contents); - return {_api, _commandBuffer}; + return {_api, _commandBuffer}; } inline MappedMemory::~MappedMemory() noexcept { - if (_api && _memory) { - _api->vkUnmapMemory(_device, _memory); - } + if (_api && _memory) { + _api->vkUnmapMemory(_device, _memory); + } } } // namespace sk |