| /* | |
| * Copyright (c) 2015-2016, 2019 The Khronos Group Inc. | |
| * Copyright (c) 2015-2016, 2019 Valve Corporation | |
| * Copyright (c) 2015-2016, 2019 LunarG, Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| * Author: Courtney Goeltzenleuchter <[email protected]> | |
| * Author: Cody Northrop <[email protected]> | |
| * Author: John Zulauf <[email protected]> | |
| */ | |
| #ifndef VKTESTBINDING_H | |
| #define VKTESTBINDING_H | |
| #include <algorithm> | |
| #include <assert.h> | |
| #include <iterator> | |
| #include <memory> | |
| #include <vector> | |
| #include "vulkan/vulkan.h" | |
| namespace vk_testing { | |
| template <class Dst, class Src> | |
| std::vector<Dst> MakeVkHandles(const std::vector<Src> &v) { | |
| std::vector<Dst> handles; | |
| handles.reserve(v.size()); | |
| std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src &o) { return o.handle(); }); | |
| return handles; | |
| } | |
| template <class Dst, class Src> | |
| std::vector<Dst> MakeVkHandles(const std::vector<Src *> &v) { | |
| std::vector<Dst> handles; | |
| handles.reserve(v.size()); | |
| std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src *o) { return o->handle(); }); | |
| return handles; | |
| } | |
| typedef void (*ErrorCallback)(const char *expr, const char *file, unsigned int line, const char *function); | |
| void set_error_callback(ErrorCallback callback); | |
| class PhysicalDevice; | |
| class Device; | |
| class Queue; | |
| class DeviceMemory; | |
| class Fence; | |
| class Semaphore; | |
| class Event; | |
| class QueryPool; | |
| class Buffer; | |
| class BufferView; | |
| class Image; | |
| class ImageView; | |
| class DepthStencilView; | |
| class Shader; | |
| class Pipeline; | |
| class PipelineDelta; | |
| class Sampler; | |
| class DescriptorSetLayout; | |
| class PipelineLayout; | |
| class DescriptorSetPool; | |
| class DescriptorSet; | |
| class CommandBuffer; | |
| class CommandPool; | |
| std::vector<VkLayerProperties> GetGlobalLayers(); | |
| std::vector<VkExtensionProperties> GetGlobalExtensions(); | |
| std::vector<VkExtensionProperties> GetGlobalExtensions(const char *pLayerName); | |
| namespace internal { | |
| template <typename T> | |
| class Handle { | |
| public: | |
| const T &handle() const { return handle_; } | |
| bool initialized() const { return (handle_ != T{}); } | |
| protected: | |
| typedef T handle_type; | |
| explicit Handle() : handle_{} {} | |
| explicit Handle(T handle) : handle_(handle) {} | |
| // handles are non-copyable | |
| Handle(const Handle &) = delete; | |
| Handle &operator=(const Handle &) = delete; | |
| // handles can be moved out | |
| Handle(Handle &&src) NOEXCEPT : handle_{src.handle_} { src.handle_ = {}; } | |
| Handle &operator=(Handle &&src) NOEXCEPT { | |
| handle_ = src.handle_; | |
| src.handle_ = {}; | |
| return *this; | |
| } | |
| void init(T handle) { | |
| assert(!initialized()); | |
| handle_ = handle; | |
| } | |
| private: | |
| T handle_; | |
| }; | |
| template <typename T> | |
| class NonDispHandle : public Handle<T> { | |
| protected: | |
| explicit NonDispHandle() : Handle<T>(), dev_handle_(VK_NULL_HANDLE) {} | |
| explicit NonDispHandle(VkDevice dev, T handle) : Handle<T>(handle), dev_handle_(dev) {} | |
| NonDispHandle(NonDispHandle &&src) : Handle<T>(std::move(src)) { | |
| dev_handle_ = src.dev_handle_; | |
| src.dev_handle_ = VK_NULL_HANDLE; | |
| } | |
| NonDispHandle &operator=(NonDispHandle &&src) { | |
| Handle<T>::operator=(std::move(src)); | |
| dev_handle_ = src.dev_handle_; | |
| src.dev_handle_ = VK_NULL_HANDLE; | |
| return *this; | |
| } | |
| const VkDevice &device() const { return dev_handle_; } | |
| void init(VkDevice dev, T handle) { | |
| assert(!Handle<T>::initialized() && dev_handle_ == VK_NULL_HANDLE); | |
| Handle<T>::init(handle); | |
| dev_handle_ = dev; | |
| } | |
| private: | |
| VkDevice dev_handle_; | |
| }; | |
| } // namespace internal | |
| class PhysicalDevice : public internal::Handle<VkPhysicalDevice> { | |
| public: | |
| explicit PhysicalDevice(VkPhysicalDevice phy) : Handle(phy) { | |
| memory_properties_ = memory_properties(); | |
| device_properties_ = properties(); | |
| } | |
| VkPhysicalDeviceProperties properties() const; | |
| VkPhysicalDeviceMemoryProperties memory_properties() const; | |
| std::vector<VkQueueFamilyProperties> queue_properties() const; | |
| VkPhysicalDeviceFeatures features() const; | |
| bool set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkMemoryPropertyFlags properties, | |
| const VkMemoryPropertyFlags forbid = 0) const; | |
| // vkEnumerateDeviceExtensionProperties() | |
| std::vector<VkExtensionProperties> extensions() const; | |
| std::vector<VkExtensionProperties> extensions(const char *pLayerName) const; | |
| // vkEnumerateLayers() | |
| std::vector<VkLayerProperties> layers() const; | |
| private: | |
| void add_extension_dependencies(uint32_t dependency_count, VkExtensionProperties *depencency_props, | |
| std::vector<VkExtensionProperties> &ext_list); | |
| VkPhysicalDeviceMemoryProperties memory_properties_; | |
| VkPhysicalDeviceProperties device_properties_; | |
| }; | |
| class QueueCreateInfoArray { | |
| private: | |
| std::vector<VkDeviceQueueCreateInfo> queue_info_; | |
| std::vector<std::vector<float>> queue_priorities_; | |
| public: | |
| QueueCreateInfoArray(const std::vector<VkQueueFamilyProperties> &queue_props); | |
| size_t size() const { return queue_info_.size(); } | |
| const VkDeviceQueueCreateInfo *data() const { return queue_info_.data(); } | |
| }; | |
| class Device : public internal::Handle<VkDevice> { | |
| public: | |
| explicit Device(VkPhysicalDevice phy) : phy_(phy) {} | |
| ~Device(); | |
| // vkCreateDevice() | |
| void init(const VkDeviceCreateInfo &info); | |
| void init(std::vector<const char *> &extensions, VkPhysicalDeviceFeatures *features = nullptr, | |
| void *create_device_pnext = nullptr); // all queues, all extensions, etc | |
| void init() { | |
| std::vector<const char *> extensions; | |
| init(extensions); | |
| }; | |
| const PhysicalDevice &phy() const { return phy_; } | |
| std::vector<const char *> GetEnabledExtensions() { return enabled_extensions_; } | |
| bool IsEnabledExtension(const char *extension); | |
| // vkGetDeviceProcAddr() | |
| PFN_vkVoidFunction get_proc(const char *name) const { return vkGetDeviceProcAddr(handle(), name); } | |
| // vkGetDeviceQueue() | |
| const std::vector<Queue *> &graphics_queues() const { return queues_[GRAPHICS]; } | |
| const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; } | |
| const std::vector<Queue *> &dma_queues() { return queues_[DMA]; } | |
| typedef std::vector<std::unique_ptr<Queue>> QueueFamilyQueues; | |
| typedef std::vector<QueueFamilyQueues> QueueFamilies; | |
| const QueueFamilyQueues &queue_family_queues(uint32_t queue_family) const; | |
| uint32_t graphics_queue_node_index_; | |
| struct Format { | |
| VkFormat format; | |
| VkImageTiling tiling; | |
| VkFlags features; | |
| }; | |
| // vkGetFormatInfo() | |
| VkFormatProperties format_properties(VkFormat format); | |
| const std::vector<Format> &formats() const { return formats_; } | |
| // vkDeviceWaitIdle() | |
| void wait(); | |
| // vkWaitForFences() | |
| VkResult wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout); | |
| VkResult wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t)-1); } | |
| // vkUpdateDescriptorSets() | |
| void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies); | |
| void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes) { | |
| return update_descriptor_sets(writes, std::vector<VkCopyDescriptorSet>()); | |
| } | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, | |
| const VkDescriptorImageInfo *image_info); | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, | |
| const VkDescriptorBufferInfo *buffer_info); | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views); | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, const std::vector<VkDescriptorImageInfo> &image_info); | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, const std::vector<VkDescriptorBufferInfo> &buffer_info); | |
| static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, const std::vector<VkBufferView> &buffer_views); | |
| static VkCopyDescriptorSet copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding, uint32_t src_array_element, | |
| const DescriptorSet &dst_set, uint32_t dst_binding, uint32_t dst_array_element, | |
| uint32_t count); | |
| private: | |
| enum QueueIndex { | |
| GRAPHICS, | |
| COMPUTE, | |
| DMA, | |
| QUEUE_COUNT, | |
| }; | |
| void init_queues(); | |
| void init_formats(); | |
| PhysicalDevice phy_; | |
| std::vector<const char *> enabled_extensions_; | |
| QueueFamilies queue_families_; | |
| std::vector<Queue *> queues_[QUEUE_COUNT]; | |
| std::vector<Format> formats_; | |
| }; | |
| class Queue : public internal::Handle<VkQueue> { | |
| public: | |
| explicit Queue(VkQueue queue, int index) : Handle(queue) { family_index_ = index; } | |
| // vkQueueSubmit() | |
| VkResult submit(const std::vector<const CommandBuffer *> &cmds, const Fence &fence, bool expect_success = true); | |
| VkResult submit(const CommandBuffer &cmd, const Fence &fence, bool expect_success = true); | |
| VkResult submit(const CommandBuffer &cmd, bool expect_success = true); | |
| // vkQueueWaitIdle() | |
| VkResult wait(); | |
| int get_family_index() { return family_index_; } | |
| private: | |
| int family_index_; | |
| }; | |
| class DeviceMemory : public internal::NonDispHandle<VkDeviceMemory> { | |
| public: | |
| ~DeviceMemory(); | |
| // vkAllocateMemory() | |
| void init(const Device &dev, const VkMemoryAllocateInfo &info); | |
| // vkMapMemory() | |
| const void *map(VkFlags flags) const; | |
| void *map(VkFlags flags); | |
| const void *map() const { return map(0); } | |
| void *map() { return map(0); } | |
| // vkUnmapMemory() | |
| void unmap() const; | |
| static VkMemoryAllocateInfo alloc_info(VkDeviceSize size, uint32_t memory_type_index); | |
| static VkMemoryAllocateInfo get_resource_alloc_info(const vk_testing::Device &dev, const VkMemoryRequirements &reqs, | |
| VkMemoryPropertyFlags mem_props); | |
| }; | |
| class Fence : public internal::NonDispHandle<VkFence> { | |
| public: | |
| ~Fence(); | |
| // vkCreateFence() | |
| void init(const Device &dev, const VkFenceCreateInfo &info); | |
| // vkGetFenceStatus() | |
| VkResult status() const { return vkGetFenceStatus(device(), handle()); } | |
| VkResult wait(VkBool32 wait_all, uint64_t timeout) const; | |
| static VkFenceCreateInfo create_info(VkFenceCreateFlags flags); | |
| static VkFenceCreateInfo create_info(); | |
| }; | |
| class Semaphore : public internal::NonDispHandle<VkSemaphore> { | |
| public: | |
| ~Semaphore(); | |
| // vkCreateSemaphore() | |
| void init(const Device &dev, const VkSemaphoreCreateInfo &info); | |
| static VkSemaphoreCreateInfo create_info(VkFlags flags); | |
| }; | |
| class Event : public internal::NonDispHandle<VkEvent> { | |
| public: | |
| ~Event(); | |
| // vkCreateEvent() | |
| void init(const Device &dev, const VkEventCreateInfo &info); | |
| // vkGetEventStatus() | |
| // vkSetEvent() | |
| // vkResetEvent() | |
| VkResult status() const { return vkGetEventStatus(device(), handle()); } | |
| void set(); | |
| void reset(); | |
| static VkEventCreateInfo create_info(VkFlags flags); | |
| }; | |
| class QueryPool : public internal::NonDispHandle<VkQueryPool> { | |
| public: | |
| ~QueryPool(); | |
| // vkCreateQueryPool() | |
| void init(const Device &dev, const VkQueryPoolCreateInfo &info); | |
| // vkGetQueryPoolResults() | |
| VkResult results(uint32_t first, uint32_t count, size_t size, void *data, size_t stride); | |
| static VkQueryPoolCreateInfo create_info(VkQueryType type, uint32_t slot_count); | |
| }; | |
| class Buffer : public internal::NonDispHandle<VkBuffer> { | |
| public: | |
| explicit Buffer() : NonDispHandle() {} | |
| explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); } | |
| explicit Buffer(const Device &dev, VkDeviceSize size) { init(dev, size); } | |
| ~Buffer(); | |
| // vkCreateBuffer() | |
| void init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props); | |
| void init(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info, 0); } | |
| void init(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags mem_props, | |
| VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, const std::vector<uint32_t> &queue_families = {}) { | |
| init(dev, create_info(size, usage, &queue_families), mem_props); | |
| } | |
| void init(const Device &dev, VkDeviceSize size) { init(dev, size, 0); } | |
| void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs, | |
| const std::vector<uint32_t> *queue_families = nullptr) { | |
| init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, queue_families), reqs); | |
| } | |
| void init_as_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs, | |
| const std::vector<uint32_t> *queue_families = nullptr) { | |
| init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs); | |
| } | |
| void init_as_src_and_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs, | |
| const std::vector<uint32_t> *queue_families = nullptr, bool memory = true) { | |
| if (memory) | |
| init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs); | |
| else | |
| init_no_mem(dev, | |
| create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families)); | |
| } | |
| void init_no_mem(const Device &dev, const VkBufferCreateInfo &info); | |
| // get the internal memory | |
| const DeviceMemory &memory() const { return internal_mem_; } | |
| DeviceMemory &memory() { return internal_mem_; } | |
| // vkGetObjectMemoryRequirements() | |
| VkMemoryRequirements memory_requirements() const; | |
| // vkBindObjectMemory() | |
| void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset); | |
| const VkBufferCreateInfo &create_info() const { return create_info_; } | |
| static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families = nullptr); | |
| VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkDeviceSize offset, | |
| VkDeviceSize size) const { | |
| VkBufferMemoryBarrier barrier = {}; | |
| barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; | |
| barrier.buffer = handle(); | |
| barrier.srcAccessMask = output_mask; | |
| barrier.dstAccessMask = input_mask; | |
| barrier.offset = offset; | |
| barrier.size = size; | |
| if (create_info_.sharingMode == VK_SHARING_MODE_CONCURRENT) { | |
| barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; | |
| barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; | |
| } | |
| return barrier; | |
| } | |
| private: | |
| VkBufferCreateInfo create_info_; | |
| DeviceMemory internal_mem_; | |
| }; | |
| class BufferView : public internal::NonDispHandle<VkBufferView> { | |
| public: | |
| ~BufferView(); | |
| // vkCreateBufferView() | |
| void init(const Device &dev, const VkBufferViewCreateInfo &info); | |
| static VkBufferViewCreateInfo createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset = 0, | |
| VkDeviceSize range = VK_WHOLE_SIZE); | |
| }; | |
| inline VkBufferViewCreateInfo BufferView::createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset, VkDeviceSize range) { | |
| VkBufferViewCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; | |
| info.pNext = nullptr; | |
| info.flags = VkFlags(0); | |
| info.buffer = buffer; | |
| info.format = format; | |
| info.offset = offset; | |
| info.range = range; | |
| return info; | |
| } | |
| class Image : public internal::NonDispHandle<VkImage> { | |
| public: | |
| explicit Image() : NonDispHandle(), format_features_(0) {} | |
| explicit Image(const Device &dev, const VkImageCreateInfo &info) : format_features_(0) { init(dev, info); } | |
| ~Image(); | |
| // vkCreateImage() | |
| void init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props); | |
| void init(const Device &dev, const VkImageCreateInfo &info) { init(dev, info, 0); } | |
| void init_no_mem(const Device &dev, const VkImageCreateInfo &info); | |
| // get the internal memory | |
| const DeviceMemory &memory() const { return internal_mem_; } | |
| DeviceMemory &memory() { return internal_mem_; } | |
| // vkGetObjectMemoryRequirements() | |
| VkMemoryRequirements memory_requirements() const; | |
| // vkBindObjectMemory() | |
| void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset); | |
| // vkGetImageSubresourceLayout() | |
| VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const; | |
| VkSubresourceLayout subresource_layout(const VkImageSubresourceLayers &subres) const; | |
| bool transparent() const; | |
| bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); } | |
| VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect) const { return subresource_range(create_info_, aspect); } | |
| VkExtent3D extent() const { return create_info_.extent; } | |
| VkExtent3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); } | |
| VkFormat format() const { return create_info_.format; } | |
| VkImageUsageFlags usage() const { return create_info_.usage; } | |
| VkSharingMode sharing_mode() const { return create_info_.sharingMode; } | |
| VkImageMemoryBarrier image_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkImageLayout old_layout, | |
| VkImageLayout new_layout, const VkImageSubresourceRange &range, | |
| uint32_t srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, | |
| uint32_t dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED) const { | |
| VkImageMemoryBarrier barrier = {}; | |
| barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; | |
| barrier.srcAccessMask = output_mask; | |
| barrier.dstAccessMask = input_mask; | |
| barrier.oldLayout = old_layout; | |
| barrier.newLayout = new_layout; | |
| barrier.image = handle(); | |
| barrier.subresourceRange = range; | |
| barrier.srcQueueFamilyIndex = srcQueueFamilyIndex; | |
| barrier.dstQueueFamilyIndex = dstQueueFamilyIndex; | |
| return barrier; | |
| } | |
| static VkImageCreateInfo create_info(); | |
| static VkImageSubresource subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer); | |
| static VkImageSubresource subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer); | |
| static VkImageSubresourceLayers subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer, | |
| uint32_t array_size); | |
| static VkImageSubresourceLayers subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, | |
| uint32_t array_size); | |
| static VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, uint32_t mip_levels, | |
| uint32_t base_array_layer, uint32_t num_layers); | |
| static VkImageSubresourceRange subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask); | |
| static VkImageSubresourceRange subresource_range(const VkImageSubresource &subres); | |
| static VkExtent2D extent(int32_t width, int32_t height); | |
| static VkExtent2D extent(const VkExtent2D &extent, uint32_t mip_level); | |
| static VkExtent2D extent(const VkExtent3D &extent); | |
| static VkExtent3D extent(int32_t width, int32_t height, int32_t depth); | |
| static VkExtent3D extent(const VkExtent3D &extent, uint32_t mip_level); | |
| private: | |
| void init_info(const Device &dev, const VkImageCreateInfo &info); | |
| VkImageCreateInfo create_info_; | |
| VkFlags format_features_; | |
| DeviceMemory internal_mem_; | |
| }; | |
| class ImageView : public internal::NonDispHandle<VkImageView> { | |
| public: | |
| ~ImageView(); | |
| // vkCreateImageView() | |
| void init(const Device &dev, const VkImageViewCreateInfo &info); | |
| }; | |
| class AccelerationStructure : public internal::NonDispHandle<VkAccelerationStructureNV> { | |
| public: | |
| explicit AccelerationStructure(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true) { | |
| init(dev, info, init_memory); | |
| } | |
| ~AccelerationStructure(); | |
| // vkCreateAccelerationStructureNV | |
| void init(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true); | |
| // vkGetAccelerationStructureMemoryRequirementsNV() | |
| VkMemoryRequirements2 memory_requirements() const; | |
| VkMemoryRequirements2 build_scratch_memory_requirements() const; | |
| uint64_t opaque_handle() const { return opaque_handle_; } | |
| const VkAccelerationStructureInfoNV &info() const { return info_; } | |
| const VkDevice &dev() const { return device(); } | |
| void create_scratch_buffer(const Device &dev, Buffer *buffer); | |
| private: | |
| VkAccelerationStructureInfoNV info_; | |
| DeviceMemory memory_; | |
| uint64_t opaque_handle_; | |
| }; | |
| class ShaderModule : public internal::NonDispHandle<VkShaderModule> { | |
| public: | |
| ~ShaderModule(); | |
| // vkCreateShaderModule() | |
| void init(const Device &dev, const VkShaderModuleCreateInfo &info); | |
| VkResult init_try(const Device &dev, const VkShaderModuleCreateInfo &info); | |
| static VkShaderModuleCreateInfo create_info(size_t code_size, const uint32_t *code, VkFlags flags); | |
| }; | |
| class Pipeline : public internal::NonDispHandle<VkPipeline> { | |
| public: | |
| ~Pipeline(); | |
| // vkCreateGraphicsPipeline() | |
| void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info); | |
| // vkCreateGraphicsPipelineDerivative() | |
| void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info, const VkPipeline basePipeline); | |
| // vkCreateComputePipeline() | |
| void init(const Device &dev, const VkComputePipelineCreateInfo &info); | |
| // vkLoadPipeline() | |
| void init(const Device &dev, size_t size, const void *data); | |
| // vkLoadPipelineDerivative() | |
| void init(const Device &dev, size_t size, const void *data, VkPipeline basePipeline); | |
| // vkCreateGraphicsPipeline with error return | |
| VkResult init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info); | |
| // vkStorePipeline() | |
| size_t store(size_t size, void *data); | |
| }; | |
| class PipelineLayout : public internal::NonDispHandle<VkPipelineLayout> { | |
| public: | |
| PipelineLayout() NOEXCEPT : NonDispHandle(){}; | |
| ~PipelineLayout(); | |
| // Move constructor for Visual Studio 2013 | |
| PipelineLayout(PipelineLayout &&src) : NonDispHandle(std::move(src)){}; | |
| PipelineLayout &operator=(PipelineLayout &&src) { | |
| this->~PipelineLayout(); | |
| this->NonDispHandle::operator=(std::move(src)); | |
| return *this; | |
| }; | |
| // vCreatePipelineLayout() | |
| void init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts); | |
| }; | |
| class Sampler : public internal::NonDispHandle<VkSampler> { | |
| public: | |
| ~Sampler(); | |
| // vkCreateSampler() | |
| void init(const Device &dev, const VkSamplerCreateInfo &info); | |
| }; | |
| class DescriptorSetLayout : public internal::NonDispHandle<VkDescriptorSetLayout> { | |
| public: | |
| DescriptorSetLayout() NOEXCEPT : NonDispHandle(){}; | |
| ~DescriptorSetLayout(); | |
| // Move constructor for Visual Studio 2013 | |
| DescriptorSetLayout(DescriptorSetLayout &&src) : NonDispHandle(std::move(src)){}; | |
| DescriptorSetLayout &operator=(DescriptorSetLayout &&src) NOEXCEPT { | |
| this->~DescriptorSetLayout(); | |
| this->NonDispHandle::operator=(std::move(src)); | |
| return *this; | |
| } | |
| // vkCreateDescriptorSetLayout() | |
| void init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info); | |
| }; | |
| class DescriptorPool : public internal::NonDispHandle<VkDescriptorPool> { | |
| public: | |
| ~DescriptorPool(); | |
| // Descriptor sets allocated from this pool will need access to the original | |
| // object | |
| VkDescriptorPool GetObj() { return pool_; } | |
| // vkCreateDescriptorPool() | |
| void init(const Device &dev, const VkDescriptorPoolCreateInfo &info); | |
| // vkResetDescriptorPool() | |
| void reset(); | |
| // vkFreeDescriptorSet() | |
| void setDynamicUsage(bool isDynamic) { dynamic_usage_ = isDynamic; } | |
| bool getDynamicUsage() { return dynamic_usage_; } | |
| // vkAllocateDescriptorSets() | |
| std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts); | |
| std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count); | |
| DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout); | |
| template <typename PoolSizes> | |
| static VkDescriptorPoolCreateInfo create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets, | |
| const PoolSizes &pool_sizes); | |
| private: | |
| VkDescriptorPool pool_; | |
| // Track whether this pool's usage is VK_DESCRIPTOR_POOL_USAGE_DYNAMIC | |
| bool dynamic_usage_; | |
| }; | |
| template <typename PoolSizes> | |
| inline VkDescriptorPoolCreateInfo DescriptorPool::create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets, | |
| const PoolSizes &pool_sizes) { | |
| VkDescriptorPoolCreateInfo info{}; | |
| info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; | |
| info.pNext = nullptr; | |
| info.flags = flags; | |
| info.maxSets = max_sets; | |
| info.poolSizeCount = pool_sizes.size(); | |
| info.pPoolSizes = (info.poolSizeCount) ? pool_sizes.data() : nullptr; | |
| return info; | |
| } | |
| class DescriptorSet : public internal::NonDispHandle<VkDescriptorSet> { | |
| public: | |
| ~DescriptorSet(); | |
| explicit DescriptorSet() : NonDispHandle() {} | |
| explicit DescriptorSet(const Device &dev, DescriptorPool *pool, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) { | |
| containing_pool_ = pool; | |
| } | |
| private: | |
| DescriptorPool *containing_pool_; | |
| }; | |
| class CommandPool : public internal::NonDispHandle<VkCommandPool> { | |
| public: | |
| ~CommandPool(); | |
| explicit CommandPool() : NonDispHandle() {} | |
| explicit CommandPool(const Device &dev, const VkCommandPoolCreateInfo &info) { init(dev, info); } | |
| void init(const Device &dev, const VkCommandPoolCreateInfo &info); | |
| static VkCommandPoolCreateInfo create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags); | |
| }; | |
| inline VkCommandPoolCreateInfo CommandPool::create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags) { | |
| VkCommandPoolCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; | |
| info.queueFamilyIndex = queue_family_index; | |
| info.flags = flags; | |
| return info; | |
| } | |
| class CommandBuffer : public internal::Handle<VkCommandBuffer> { | |
| public: | |
| ~CommandBuffer(); | |
| explicit CommandBuffer() : Handle() {} | |
| explicit CommandBuffer(const Device &dev, const VkCommandBufferAllocateInfo &info) { init(dev, info); } | |
| // vkAllocateCommandBuffers() | |
| void init(const Device &dev, const VkCommandBufferAllocateInfo &info); | |
| // vkBeginCommandBuffer() | |
| void begin(const VkCommandBufferBeginInfo *info); | |
| void begin(); | |
| // vkEndCommandBuffer() | |
| // vkResetCommandBuffer() | |
| void end(); | |
| void reset(VkCommandBufferResetFlags flags); | |
| void reset() { reset(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); } | |
| static VkCommandBufferAllocateInfo create_info(VkCommandPool const &pool); | |
| private: | |
| VkDevice dev_handle_; | |
| VkCommandPool cmd_pool_; | |
| }; | |
| inline VkMemoryAllocateInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index) { | |
| VkMemoryAllocateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; | |
| info.allocationSize = size; | |
| info.memoryTypeIndex = memory_type_index; | |
| return info; | |
| } | |
| inline VkBufferCreateInfo Buffer::create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families) { | |
| VkBufferCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; | |
| info.size = size; | |
| info.usage = usage; | |
| if (queue_families && queue_families->size() > 1) { | |
| info.sharingMode = VK_SHARING_MODE_CONCURRENT; | |
| info.queueFamilyIndexCount = static_cast<uint32_t>(queue_families->size()); | |
| info.pQueueFamilyIndices = queue_families->data(); | |
| } | |
| return info; | |
| } | |
| inline VkFenceCreateInfo Fence::create_info(VkFenceCreateFlags flags) { | |
| VkFenceCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; | |
| info.flags = flags; | |
| return info; | |
| } | |
| inline VkFenceCreateInfo Fence::create_info() { | |
| VkFenceCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; | |
| return info; | |
| } | |
| inline VkSemaphoreCreateInfo Semaphore::create_info(VkFlags flags) { | |
| VkSemaphoreCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; | |
| info.flags = flags; | |
| return info; | |
| } | |
| inline VkEventCreateInfo Event::create_info(VkFlags flags) { | |
| VkEventCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; | |
| info.flags = flags; | |
| return info; | |
| } | |
| inline VkQueryPoolCreateInfo QueryPool::create_info(VkQueryType type, uint32_t slot_count) { | |
| VkQueryPoolCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; | |
| info.queryType = type; | |
| info.queryCount = slot_count; | |
| return info; | |
| } | |
| inline VkImageCreateInfo Image::create_info() { | |
| VkImageCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; | |
| info.extent.width = 1; | |
| info.extent.height = 1; | |
| info.extent.depth = 1; | |
| info.mipLevels = 1; | |
| info.arrayLayers = 1; | |
| info.samples = VK_SAMPLE_COUNT_1_BIT; | |
| return info; | |
| } | |
| inline VkImageSubresource Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer) { | |
| VkImageSubresource subres = {}; | |
| if (aspect == 0) { | |
| assert(!"Invalid VkImageAspectFlags"); | |
| } | |
| subres.aspectMask = aspect; | |
| subres.mipLevel = mip_level; | |
| subres.arrayLayer = array_layer; | |
| return subres; | |
| } | |
| inline VkImageSubresource Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer) { | |
| return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer); | |
| } | |
| inline VkImageSubresourceLayers Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer, | |
| uint32_t array_size) { | |
| VkImageSubresourceLayers subres = {}; | |
| switch (aspect) { | |
| case VK_IMAGE_ASPECT_COLOR_BIT: | |
| case VK_IMAGE_ASPECT_DEPTH_BIT: | |
| case VK_IMAGE_ASPECT_STENCIL_BIT: | |
| case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT: | |
| /* valid */ | |
| break; | |
| default: | |
| assert(!"Invalid VkImageAspectFlags"); | |
| } | |
| subres.aspectMask = aspect; | |
| subres.mipLevel = mip_level; | |
| subres.baseArrayLayer = array_layer; | |
| subres.layerCount = array_size; | |
| return subres; | |
| } | |
| inline VkImageSubresourceLayers Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, | |
| uint32_t array_size) { | |
| return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer, array_size); | |
| } | |
| inline VkImageSubresourceRange Image::subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, | |
| uint32_t mip_levels, uint32_t base_array_layer, uint32_t num_layers) { | |
| VkImageSubresourceRange range = {}; | |
| if (aspect_mask == 0) { | |
| assert(!"Invalid VkImageAspectFlags"); | |
| } | |
| range.aspectMask = aspect_mask; | |
| range.baseMipLevel = base_mip_level; | |
| range.levelCount = mip_levels; | |
| range.baseArrayLayer = base_array_layer; | |
| range.layerCount = num_layers; | |
| return range; | |
| } | |
| inline VkImageSubresourceRange Image::subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask) { | |
| return subresource_range(aspect_mask, 0, info.mipLevels, 0, info.arrayLayers); | |
| } | |
| inline VkImageSubresourceRange Image::subresource_range(const VkImageSubresource &subres) { | |
| return subresource_range(subres.aspectMask, subres.mipLevel, 1, subres.arrayLayer, 1); | |
| } | |
| inline VkExtent2D Image::extent(int32_t width, int32_t height) { | |
| VkExtent2D extent = {}; | |
| extent.width = width; | |
| extent.height = height; | |
| return extent; | |
| } | |
| inline VkExtent2D Image::extent(const VkExtent2D &extent, uint32_t mip_level) { | |
| const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1; | |
| const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1; | |
| return Image::extent(width, height); | |
| } | |
| inline VkExtent2D Image::extent(const VkExtent3D &extent) { return Image::extent(extent.width, extent.height); } | |
| inline VkExtent3D Image::extent(int32_t width, int32_t height, int32_t depth) { | |
| VkExtent3D extent = {}; | |
| extent.width = width; | |
| extent.height = height; | |
| extent.depth = depth; | |
| return extent; | |
| } | |
| inline VkExtent3D Image::extent(const VkExtent3D &extent, uint32_t mip_level) { | |
| const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1; | |
| const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1; | |
| const int32_t depth = (extent.depth >> mip_level) ? extent.depth >> mip_level : 1; | |
| return Image::extent(width, height, depth); | |
| } | |
| inline VkShaderModuleCreateInfo ShaderModule::create_info(size_t code_size, const uint32_t *code, VkFlags flags) { | |
| VkShaderModuleCreateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; | |
| info.codeSize = code_size; | |
| info.pCode = code; | |
| info.flags = flags; | |
| return info; | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, | |
| const VkDescriptorImageInfo *image_info) { | |
| VkWriteDescriptorSet write = {}; | |
| write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; | |
| write.dstSet = set.handle(); | |
| write.dstBinding = binding; | |
| write.dstArrayElement = array_element; | |
| write.descriptorCount = count; | |
| write.descriptorType = type; | |
| write.pImageInfo = image_info; | |
| return write; | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, | |
| const VkDescriptorBufferInfo *buffer_info) { | |
| VkWriteDescriptorSet write = {}; | |
| write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; | |
| write.dstSet = set.handle(); | |
| write.dstBinding = binding; | |
| write.dstArrayElement = array_element; | |
| write.descriptorCount = count; | |
| write.descriptorType = type; | |
| write.pBufferInfo = buffer_info; | |
| return write; | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views) { | |
| VkWriteDescriptorSet write = {}; | |
| write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; | |
| write.dstSet = set.handle(); | |
| write.dstBinding = binding; | |
| write.dstArrayElement = array_element; | |
| write.descriptorCount = count; | |
| write.descriptorType = type; | |
| write.pTexelBufferView = buffer_views; | |
| return write; | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, | |
| const std::vector<VkDescriptorImageInfo> &image_info) { | |
| return write_descriptor_set(set, binding, array_element, type, image_info.size(), &image_info[0]); | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, | |
| const std::vector<VkDescriptorBufferInfo> &buffer_info) { | |
| return write_descriptor_set(set, binding, array_element, type, buffer_info.size(), &buffer_info[0]); | |
| } | |
| inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element, | |
| VkDescriptorType type, const std::vector<VkBufferView> &buffer_views) { | |
| return write_descriptor_set(set, binding, array_element, type, buffer_views.size(), &buffer_views[0]); | |
| } | |
| inline VkCopyDescriptorSet Device::copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding, | |
| uint32_t src_array_element, const DescriptorSet &dst_set, | |
| uint32_t dst_binding, uint32_t dst_array_element, uint32_t count) { | |
| VkCopyDescriptorSet copy = {}; | |
| copy.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; | |
| copy.srcSet = src_set.handle(); | |
| copy.srcBinding = src_binding; | |
| copy.srcArrayElement = src_array_element; | |
| copy.dstSet = dst_set.handle(); | |
| copy.dstBinding = dst_binding; | |
| copy.dstArrayElement = dst_array_element; | |
| copy.descriptorCount = count; | |
| return copy; | |
| } | |
| inline VkCommandBufferAllocateInfo CommandBuffer::create_info(VkCommandPool const &pool) { | |
| VkCommandBufferAllocateInfo info = {}; | |
| info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; | |
| info.commandPool = pool; | |
| info.commandBufferCount = 1; | |
| return info; | |
| } | |
| } // namespace vk_testing | |
| #endif // VKTESTBINDING_H |