2 * Copyright (c) 2015-2016 The Khronos Group Inc.
3 * Copyright (c) 2015-2016 Valve Corporation
4 * Copyright (c) 2015-2016 LunarG, Inc.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
18 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
19 * Author: Cody Northrop <cody@lunarg.com>
20 * Author: John Zulauf <jzulauf@lunarg.com>
23 #ifndef VKTESTBINDING_H
24 #define VKTESTBINDING_H
32 #include "vulkan/vulkan.h"
34 namespace vk_testing {
36 template <class Dst, class Src>
37 std::vector<Dst> MakeVkHandles(const std::vector<Src> &v) {
38 std::vector<Dst> handles;
39 handles.reserve(v.size());
40 std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src &o) { return o.handle(); });
44 template <class Dst, class Src>
45 std::vector<Dst> MakeVkHandles(const std::vector<Src *> &v) {
46 std::vector<Dst> handles;
47 handles.reserve(v.size());
48 std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src *o) { return o->handle(); });
52 typedef void (*ErrorCallback)(const char *expr, const char *file, unsigned int line, const char *function);
53 void set_error_callback(ErrorCallback callback);
67 class DepthStencilView;
72 class DescriptorSetLayout;
74 class DescriptorSetPool;
79 std::vector<VkLayerProperties> GetGlobalLayers();
80 std::vector<VkExtensionProperties> GetGlobalExtensions();
81 std::vector<VkExtensionProperties> GetGlobalExtensions(const char *pLayerName);
88 const T &handle() const { return handle_; }
89 bool initialized() const { return (handle_ != T{}); }
92 typedef T handle_type;
94 explicit Handle() : handle_{} {}
95 explicit Handle(T handle) : handle_(handle) {}
97 // handles are non-copyable
98 Handle(const Handle &) = delete;
99 Handle &operator=(const Handle &) = delete;
101 // handles can be moved out
102 Handle(Handle &&src) NOEXCEPT : handle_{src.handle_} { src.handle_ = {}; }
103 Handle &operator=(Handle &&src) NOEXCEPT {
104 handle_ = src.handle_;
109 void init(T handle) {
110 assert(!initialized());
118 template <typename T>
119 class NonDispHandle : public Handle<T> {
121 explicit NonDispHandle() : Handle<T>(), dev_handle_(VK_NULL_HANDLE) {}
122 explicit NonDispHandle(VkDevice dev, T handle) : Handle<T>(handle), dev_handle_(dev) {}
124 NonDispHandle(NonDispHandle &&src) : Handle<T>(std::move(src)) {
125 dev_handle_ = src.dev_handle_;
126 src.dev_handle_ = VK_NULL_HANDLE;
128 NonDispHandle &operator=(NonDispHandle &&src) {
129 Handle<T>::operator=(std::move(src));
130 dev_handle_ = src.dev_handle_;
131 src.dev_handle_ = VK_NULL_HANDLE;
135 const VkDevice &device() const { return dev_handle_; }
137 void init(VkDevice dev, T handle) {
138 assert(!Handle<T>::initialized() && dev_handle_ == VK_NULL_HANDLE);
139 Handle<T>::init(handle);
144 VkDevice dev_handle_;
147 } // namespace internal
149 class PhysicalDevice : public internal::Handle<VkPhysicalDevice> {
151 explicit PhysicalDevice(VkPhysicalDevice phy) : Handle(phy) {
152 memory_properties_ = memory_properties();
153 device_properties_ = properties();
156 VkPhysicalDeviceProperties properties() const;
157 VkPhysicalDeviceMemoryProperties memory_properties() const;
158 std::vector<VkQueueFamilyProperties> queue_properties() const;
159 VkPhysicalDeviceFeatures features() const;
161 bool set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkMemoryPropertyFlags properties,
162 const VkMemoryPropertyFlags forbid = 0) const;
164 // vkEnumerateDeviceExtensionProperties()
165 std::vector<VkExtensionProperties> extensions() const;
166 std::vector<VkExtensionProperties> extensions(const char *pLayerName) const;
168 // vkEnumerateLayers()
169 std::vector<VkLayerProperties> layers() const;
172 void add_extension_dependencies(uint32_t dependency_count, VkExtensionProperties *depencency_props,
173 std::vector<VkExtensionProperties> &ext_list);
175 VkPhysicalDeviceMemoryProperties memory_properties_;
177 VkPhysicalDeviceProperties device_properties_;
180 class QueueCreateInfoArray {
182 std::vector<VkDeviceQueueCreateInfo> queue_info_;
183 std::vector<std::vector<float>> queue_priorities_;
186 QueueCreateInfoArray(const std::vector<VkQueueFamilyProperties> &queue_props);
187 size_t size() const { return queue_info_.size(); }
188 const VkDeviceQueueCreateInfo *data() const { return queue_info_.data(); }
191 class Device : public internal::Handle<VkDevice> {
193 explicit Device(VkPhysicalDevice phy) : phy_(phy) {}
197 void init(const VkDeviceCreateInfo &info);
198 void init(std::vector<const char *> &extensions,
199 VkPhysicalDeviceFeatures *features = nullptr); // all queues, all extensions, etc
201 std::vector<const char *> extensions;
205 const PhysicalDevice &phy() const { return phy_; }
207 std::vector<const char *> GetEnabledExtensions() { return enabled_extensions_; }
208 bool IsEnbledExtension(const char *extension);
210 // vkGetDeviceProcAddr()
211 PFN_vkVoidFunction get_proc(const char *name) const { return vkGetDeviceProcAddr(handle(), name); }
213 // vkGetDeviceQueue()
214 const std::vector<Queue *> &graphics_queues() const { return queues_[GRAPHICS]; }
215 const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; }
216 const std::vector<Queue *> &dma_queues() { return queues_[DMA]; }
218 typedef std::vector<std::unique_ptr<Queue>> QueueFamilyQueues;
219 typedef std::vector<QueueFamilyQueues> QueueFamilies;
220 const QueueFamilyQueues &queue_family_queues(uint32_t queue_family) const;
222 uint32_t graphics_queue_node_index_;
226 VkImageTiling tiling;
230 VkFormatProperties format_properties(VkFormat format);
231 const std::vector<Format> &formats() const { return formats_; }
233 // vkDeviceWaitIdle()
237 VkResult wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout);
238 VkResult wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t)-1); }
240 // vkUpdateDescriptorSets()
241 void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies);
242 void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes) {
243 return update_descriptor_sets(writes, std::vector<VkCopyDescriptorSet>());
246 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
247 VkDescriptorType type, uint32_t count,
248 const VkDescriptorImageInfo *image_info);
249 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
250 VkDescriptorType type, uint32_t count,
251 const VkDescriptorBufferInfo *buffer_info);
252 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
253 VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views);
254 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
255 VkDescriptorType type, const std::vector<VkDescriptorImageInfo> &image_info);
256 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
257 VkDescriptorType type, const std::vector<VkDescriptorBufferInfo> &buffer_info);
258 static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
259 VkDescriptorType type, const std::vector<VkBufferView> &buffer_views);
261 static VkCopyDescriptorSet copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding, uint32_t src_array_element,
262 const DescriptorSet &dst_set, uint32_t dst_binding, uint32_t dst_array_element,
278 std::vector<const char *> enabled_extensions_;
280 QueueFamilies queue_families_;
281 std::vector<Queue *> queues_[QUEUE_COUNT];
282 std::vector<Format> formats_;
285 class Queue : public internal::Handle<VkQueue> {
287 explicit Queue(VkQueue queue, int index) : Handle(queue) { family_index_ = index; }
290 VkResult submit(const std::vector<const CommandBuffer *> &cmds, const Fence &fence, bool expect_success = true);
291 VkResult submit(const CommandBuffer &cmd, const Fence &fence, bool expect_success = true);
292 VkResult submit(const CommandBuffer &cmd, bool expect_success = true);
297 int get_family_index() { return family_index_; }
303 class DeviceMemory : public internal::NonDispHandle<VkDeviceMemory> {
307 // vkAllocateMemory()
308 void init(const Device &dev, const VkMemoryAllocateInfo &info);
311 const void *map(VkFlags flags) const;
312 void *map(VkFlags flags);
313 const void *map() const { return map(0); }
314 void *map() { return map(0); }
319 static VkMemoryAllocateInfo alloc_info(VkDeviceSize size, uint32_t memory_type_index);
320 static VkMemoryAllocateInfo get_resource_alloc_info(const vk_testing::Device &dev, const VkMemoryRequirements &reqs,
321 VkMemoryPropertyFlags mem_props);
324 class Fence : public internal::NonDispHandle<VkFence> {
329 void init(const Device &dev, const VkFenceCreateInfo &info);
331 // vkGetFenceStatus()
332 VkResult status() const { return vkGetFenceStatus(device(), handle()); }
333 VkResult wait(VkBool32 wait_all, uint64_t timeout) const;
335 static VkFenceCreateInfo create_info(VkFenceCreateFlags flags);
336 static VkFenceCreateInfo create_info();
339 class Semaphore : public internal::NonDispHandle<VkSemaphore> {
343 // vkCreateSemaphore()
344 void init(const Device &dev, const VkSemaphoreCreateInfo &info);
346 static VkSemaphoreCreateInfo create_info(VkFlags flags);
349 class Event : public internal::NonDispHandle<VkEvent> {
354 void init(const Device &dev, const VkEventCreateInfo &info);
356 // vkGetEventStatus()
359 VkResult status() const { return vkGetEventStatus(device(), handle()); }
363 static VkEventCreateInfo create_info(VkFlags flags);
366 class QueryPool : public internal::NonDispHandle<VkQueryPool> {
370 // vkCreateQueryPool()
371 void init(const Device &dev, const VkQueryPoolCreateInfo &info);
373 // vkGetQueryPoolResults()
374 VkResult results(uint32_t first, uint32_t count, size_t size, void *data, size_t stride);
376 static VkQueryPoolCreateInfo create_info(VkQueryType type, uint32_t slot_count);
379 class Buffer : public internal::NonDispHandle<VkBuffer> {
381 explicit Buffer() : NonDispHandle() {}
382 explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); }
383 explicit Buffer(const Device &dev, VkDeviceSize size) { init(dev, size); }
388 void init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props);
389 void init(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info, 0); }
390 void init(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags mem_props) { init(dev, create_info(size, 0), mem_props); }
391 void init(const Device &dev, VkDeviceSize size) { init(dev, size, 0); }
392 void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
393 const std::vector<uint32_t> *queue_families = nullptr) {
394 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, queue_families), reqs);
396 void init_as_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
397 const std::vector<uint32_t> *queue_families = nullptr) {
398 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs);
400 void init_as_src_and_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
401 const std::vector<uint32_t> *queue_families = nullptr) {
402 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs);
404 void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
406 // get the internal memory
407 const DeviceMemory &memory() const { return internal_mem_; }
408 DeviceMemory &memory() { return internal_mem_; }
410 // vkGetObjectMemoryRequirements()
411 VkMemoryRequirements memory_requirements() const;
413 // vkBindObjectMemory()
414 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
416 const VkBufferCreateInfo &create_info() const { return create_info_; }
417 static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families = nullptr);
419 VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkDeviceSize offset,
420 VkDeviceSize size) const {
421 VkBufferMemoryBarrier barrier = {};
422 barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
423 barrier.buffer = handle();
424 barrier.srcAccessMask = output_mask;
425 barrier.dstAccessMask = input_mask;
426 barrier.offset = offset;
428 if (create_info_.sharingMode == VK_SHARING_MODE_CONCURRENT) {
429 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
430 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
436 VkBufferCreateInfo create_info_;
438 DeviceMemory internal_mem_;
441 class BufferView : public internal::NonDispHandle<VkBufferView> {
445 // vkCreateBufferView()
446 void init(const Device &dev, const VkBufferViewCreateInfo &info);
447 static VkBufferViewCreateInfo createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset = 0,
448 VkDeviceSize range = VK_WHOLE_SIZE);
451 inline VkBufferViewCreateInfo BufferView::createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset, VkDeviceSize range) {
452 VkBufferViewCreateInfo info = {};
453 info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
454 info.pNext = nullptr;
455 info.flags = VkFlags(0);
456 info.buffer = buffer;
457 info.format = format;
458 info.offset = offset;
463 class Image : public internal::NonDispHandle<VkImage> {
465 explicit Image() : NonDispHandle(), format_features_(0) {}
466 explicit Image(const Device &dev, const VkImageCreateInfo &info) : format_features_(0) { init(dev, info); }
471 void init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props);
472 void init(const Device &dev, const VkImageCreateInfo &info) { init(dev, info, 0); }
473 void init_no_mem(const Device &dev, const VkImageCreateInfo &info);
475 // get the internal memory
476 const DeviceMemory &memory() const { return internal_mem_; }
477 DeviceMemory &memory() { return internal_mem_; }
479 // vkGetObjectMemoryRequirements()
480 VkMemoryRequirements memory_requirements() const;
482 // vkBindObjectMemory()
483 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
485 // vkGetImageSubresourceLayout()
486 VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const;
487 VkSubresourceLayout subresource_layout(const VkImageSubresourceLayers &subres) const;
489 bool transparent() const;
490 bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); }
492 VkImageSubresourceRange subresource_range(VkImageAspectFlagBits aspect) const {
493 return subresource_range(create_info_, aspect);
495 VkExtent3D extent() const { return create_info_.extent; }
496 VkExtent3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); }
497 VkFormat format() const { return create_info_.format; }
498 VkImageUsageFlags usage() const { return create_info_.usage; }
499 VkSharingMode sharing_mode() const { return create_info_.sharingMode; }
500 VkImageMemoryBarrier image_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkImageLayout old_layout,
501 VkImageLayout new_layout, const VkImageSubresourceRange &range) const {
502 VkImageMemoryBarrier barrier = {};
503 barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
504 barrier.srcAccessMask = output_mask;
505 barrier.dstAccessMask = input_mask;
506 barrier.oldLayout = old_layout;
507 barrier.newLayout = new_layout;
508 barrier.image = handle();
509 barrier.subresourceRange = range;
511 if (sharing_mode() == VK_SHARING_MODE_CONCURRENT) {
512 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
513 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
518 static VkImageCreateInfo create_info();
519 static VkImageSubresource subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer);
520 static VkImageSubresource subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer);
521 static VkImageSubresourceLayers subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
522 uint32_t array_size);
523 static VkImageSubresourceLayers subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
524 uint32_t array_size);
525 static VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, uint32_t mip_levels,
526 uint32_t base_array_layer, uint32_t num_layers);
527 static VkImageSubresourceRange subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask);
528 static VkImageSubresourceRange subresource_range(const VkImageSubresource &subres);
530 static VkExtent2D extent(int32_t width, int32_t height);
531 static VkExtent2D extent(const VkExtent2D &extent, uint32_t mip_level);
532 static VkExtent2D extent(const VkExtent3D &extent);
534 static VkExtent3D extent(int32_t width, int32_t height, int32_t depth);
535 static VkExtent3D extent(const VkExtent3D &extent, uint32_t mip_level);
538 void init_info(const Device &dev, const VkImageCreateInfo &info);
540 VkImageCreateInfo create_info_;
541 VkFlags format_features_;
543 DeviceMemory internal_mem_;
546 class ImageView : public internal::NonDispHandle<VkImageView> {
550 // vkCreateImageView()
551 void init(const Device &dev, const VkImageViewCreateInfo &info);
554 class ShaderModule : public internal::NonDispHandle<VkShaderModule> {
558 // vkCreateShaderModule()
559 void init(const Device &dev, const VkShaderModuleCreateInfo &info);
560 VkResult init_try(const Device &dev, const VkShaderModuleCreateInfo &info);
562 static VkShaderModuleCreateInfo create_info(size_t code_size, const uint32_t *code, VkFlags flags);
565 class Pipeline : public internal::NonDispHandle<VkPipeline> {
569 // vkCreateGraphicsPipeline()
570 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
571 // vkCreateGraphicsPipelineDerivative()
572 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info, const VkPipeline basePipeline);
573 // vkCreateComputePipeline()
574 void init(const Device &dev, const VkComputePipelineCreateInfo &info);
576 void init(const Device &dev, size_t size, const void *data);
577 // vkLoadPipelineDerivative()
578 void init(const Device &dev, size_t size, const void *data, VkPipeline basePipeline);
580 // vkCreateGraphicsPipeline with error return
581 VkResult init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
584 size_t store(size_t size, void *data);
587 class PipelineLayout : public internal::NonDispHandle<VkPipelineLayout> {
589 PipelineLayout() NOEXCEPT : NonDispHandle(){};
592 // Move constructor for Visual Studio 2013
593 PipelineLayout(PipelineLayout &&src) : NonDispHandle(std::move(src)){};
595 PipelineLayout &operator=(PipelineLayout &&src) {
596 this->~PipelineLayout();
597 this->NonDispHandle::operator=(std::move(src));
601 // vCreatePipelineLayout()
602 void init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts);
605 class Sampler : public internal::NonDispHandle<VkSampler> {
610 void init(const Device &dev, const VkSamplerCreateInfo &info);
613 class DescriptorSetLayout : public internal::NonDispHandle<VkDescriptorSetLayout> {
615 DescriptorSetLayout() NOEXCEPT : NonDispHandle(){};
616 ~DescriptorSetLayout();
618 // Move constructor for Visual Studio 2013
619 DescriptorSetLayout(DescriptorSetLayout &&src) : NonDispHandle(std::move(src)){};
621 DescriptorSetLayout &operator=(DescriptorSetLayout &&src) NOEXCEPT {
622 this->~DescriptorSetLayout();
623 this->NonDispHandle::operator=(std::move(src));
627 // vkCreateDescriptorSetLayout()
628 void init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info);
631 class DescriptorPool : public internal::NonDispHandle<VkDescriptorPool> {
635 // Descriptor sets allocated from this pool will need access to the original
637 VkDescriptorPool GetObj() { return pool_; }
639 // vkCreateDescriptorPool()
640 void init(const Device &dev, const VkDescriptorPoolCreateInfo &info);
642 // vkResetDescriptorPool()
645 // vkFreeDescriptorSet()
646 void setDynamicUsage(bool isDynamic) { dynamic_usage_ = isDynamic; }
647 bool getDynamicUsage() { return dynamic_usage_; }
649 // vkAllocateDescriptorSets()
650 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
651 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count);
652 DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout);
654 template <typename PoolSizes>
655 static VkDescriptorPoolCreateInfo create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
656 const PoolSizes &pool_sizes);
659 VkDescriptorPool pool_;
661 // Track whether this pool's usage is VK_DESCRIPTOR_POOL_USAGE_DYNAMIC
665 template <typename PoolSizes>
666 inline VkDescriptorPoolCreateInfo DescriptorPool::create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
667 const PoolSizes &pool_sizes) {
668 VkDescriptorPoolCreateInfo info{};
669 info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
670 info.pNext = nullptr;
672 info.maxSets = max_sets;
673 info.poolSizeCount = pool_sizes.size();
674 info.pPoolSizes = (info.poolSizeCount) ? pool_sizes.data() : nullptr;
678 class DescriptorSet : public internal::NonDispHandle<VkDescriptorSet> {
682 explicit DescriptorSet() : NonDispHandle() {}
683 explicit DescriptorSet(const Device &dev, DescriptorPool *pool, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) {
684 containing_pool_ = pool;
688 DescriptorPool *containing_pool_;
691 class CommandPool : public internal::NonDispHandle<VkCommandPool> {
695 explicit CommandPool() : NonDispHandle() {}
696 explicit CommandPool(const Device &dev, const VkCommandPoolCreateInfo &info) { init(dev, info); }
698 void init(const Device &dev, const VkCommandPoolCreateInfo &info);
700 static VkCommandPoolCreateInfo create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags);
703 inline VkCommandPoolCreateInfo CommandPool::create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags) {
704 VkCommandPoolCreateInfo info = {};
705 info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
706 info.queueFamilyIndex = queue_family_index;
711 class CommandBuffer : public internal::Handle<VkCommandBuffer> {
715 explicit CommandBuffer() : Handle() {}
716 explicit CommandBuffer(const Device &dev, const VkCommandBufferAllocateInfo &info) { init(dev, info); }
718 // vkAllocateCommandBuffers()
719 void init(const Device &dev, const VkCommandBufferAllocateInfo &info);
721 // vkBeginCommandBuffer()
722 void begin(const VkCommandBufferBeginInfo *info);
725 // vkEndCommandBuffer()
726 // vkResetCommandBuffer()
728 void reset(VkCommandBufferResetFlags flags);
729 void reset() { reset(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
731 static VkCommandBufferAllocateInfo create_info(VkCommandPool const &pool);
734 VkDevice dev_handle_;
735 VkCommandPool cmd_pool_;
738 inline VkMemoryAllocateInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index) {
739 VkMemoryAllocateInfo info = {};
740 info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
741 info.allocationSize = size;
742 info.memoryTypeIndex = memory_type_index;
746 inline VkBufferCreateInfo Buffer::create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families) {
747 VkBufferCreateInfo info = {};
748 info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
752 if (queue_families && queue_families->size() > 1) {
753 info.sharingMode = VK_SHARING_MODE_CONCURRENT;
754 info.queueFamilyIndexCount = static_cast<uint32_t>(queue_families->size());
755 info.pQueueFamilyIndices = queue_families->data();
761 inline VkFenceCreateInfo Fence::create_info(VkFenceCreateFlags flags) {
762 VkFenceCreateInfo info = {};
763 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
768 inline VkFenceCreateInfo Fence::create_info() {
769 VkFenceCreateInfo info = {};
770 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
774 inline VkSemaphoreCreateInfo Semaphore::create_info(VkFlags flags) {
775 VkSemaphoreCreateInfo info = {};
776 info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
781 inline VkEventCreateInfo Event::create_info(VkFlags flags) {
782 VkEventCreateInfo info = {};
783 info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
788 inline VkQueryPoolCreateInfo QueryPool::create_info(VkQueryType type, uint32_t slot_count) {
789 VkQueryPoolCreateInfo info = {};
790 info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
791 info.queryType = type;
792 info.queryCount = slot_count;
796 inline VkImageCreateInfo Image::create_info() {
797 VkImageCreateInfo info = {};
798 info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
799 info.extent.width = 1;
800 info.extent.height = 1;
801 info.extent.depth = 1;
803 info.arrayLayers = 1;
804 info.samples = VK_SAMPLE_COUNT_1_BIT;
808 inline VkImageSubresource Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer) {
809 VkImageSubresource subres = {};
811 assert(!"Invalid VkImageAspectFlags");
813 subres.aspectMask = aspect;
814 subres.mipLevel = mip_level;
815 subres.arrayLayer = array_layer;
819 inline VkImageSubresource Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer) {
820 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer);
823 inline VkImageSubresourceLayers Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
824 uint32_t array_size) {
825 VkImageSubresourceLayers subres = {};
827 case VK_IMAGE_ASPECT_COLOR_BIT:
828 case VK_IMAGE_ASPECT_DEPTH_BIT:
829 case VK_IMAGE_ASPECT_STENCIL_BIT:
830 case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT:
834 assert(!"Invalid VkImageAspectFlags");
836 subres.aspectMask = aspect;
837 subres.mipLevel = mip_level;
838 subres.baseArrayLayer = array_layer;
839 subres.layerCount = array_size;
843 inline VkImageSubresourceLayers Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
844 uint32_t array_size) {
845 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer, array_size);
848 inline VkImageSubresourceRange Image::subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level,
849 uint32_t mip_levels, uint32_t base_array_layer, uint32_t num_layers) {
850 VkImageSubresourceRange range = {};
851 if (aspect_mask == 0) {
852 assert(!"Invalid VkImageAspectFlags");
854 range.aspectMask = aspect_mask;
855 range.baseMipLevel = base_mip_level;
856 range.levelCount = mip_levels;
857 range.baseArrayLayer = base_array_layer;
858 range.layerCount = num_layers;
862 inline VkImageSubresourceRange Image::subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask) {
863 return subresource_range(aspect_mask, 0, info.mipLevels, 0, info.arrayLayers);
866 inline VkImageSubresourceRange Image::subresource_range(const VkImageSubresource &subres) {
867 return subresource_range(subres.aspectMask, subres.mipLevel, 1, subres.arrayLayer, 1);
870 inline VkExtent2D Image::extent(int32_t width, int32_t height) {
871 VkExtent2D extent = {};
872 extent.width = width;
873 extent.height = height;
877 inline VkExtent2D Image::extent(const VkExtent2D &extent, uint32_t mip_level) {
878 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
879 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
880 return Image::extent(width, height);
883 inline VkExtent2D Image::extent(const VkExtent3D &extent) { return Image::extent(extent.width, extent.height); }
885 inline VkExtent3D Image::extent(int32_t width, int32_t height, int32_t depth) {
886 VkExtent3D extent = {};
887 extent.width = width;
888 extent.height = height;
889 extent.depth = depth;
893 inline VkExtent3D Image::extent(const VkExtent3D &extent, uint32_t mip_level) {
894 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
895 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
896 const int32_t depth = (extent.depth >> mip_level) ? extent.depth >> mip_level : 1;
897 return Image::extent(width, height, depth);
900 inline VkShaderModuleCreateInfo ShaderModule::create_info(size_t code_size, const uint32_t *code, VkFlags flags) {
901 VkShaderModuleCreateInfo info = {};
902 info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
903 info.codeSize = code_size;
909 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
910 VkDescriptorType type, uint32_t count,
911 const VkDescriptorImageInfo *image_info) {
912 VkWriteDescriptorSet write = {};
913 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
914 write.dstSet = set.handle();
915 write.dstBinding = binding;
916 write.dstArrayElement = array_element;
917 write.descriptorCount = count;
918 write.descriptorType = type;
919 write.pImageInfo = image_info;
923 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
924 VkDescriptorType type, uint32_t count,
925 const VkDescriptorBufferInfo *buffer_info) {
926 VkWriteDescriptorSet write = {};
927 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
928 write.dstSet = set.handle();
929 write.dstBinding = binding;
930 write.dstArrayElement = array_element;
931 write.descriptorCount = count;
932 write.descriptorType = type;
933 write.pBufferInfo = buffer_info;
937 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
938 VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views) {
939 VkWriteDescriptorSet write = {};
940 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
941 write.dstSet = set.handle();
942 write.dstBinding = binding;
943 write.dstArrayElement = array_element;
944 write.descriptorCount = count;
945 write.descriptorType = type;
946 write.pTexelBufferView = buffer_views;
950 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
951 VkDescriptorType type,
952 const std::vector<VkDescriptorImageInfo> &image_info) {
953 return write_descriptor_set(set, binding, array_element, type, image_info.size(), &image_info[0]);
956 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
957 VkDescriptorType type,
958 const std::vector<VkDescriptorBufferInfo> &buffer_info) {
959 return write_descriptor_set(set, binding, array_element, type, buffer_info.size(), &buffer_info[0]);
962 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
963 VkDescriptorType type, const std::vector<VkBufferView> &buffer_views) {
964 return write_descriptor_set(set, binding, array_element, type, buffer_views.size(), &buffer_views[0]);
967 inline VkCopyDescriptorSet Device::copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding,
968 uint32_t src_array_element, const DescriptorSet &dst_set,
969 uint32_t dst_binding, uint32_t dst_array_element, uint32_t count) {
970 VkCopyDescriptorSet copy = {};
971 copy.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
972 copy.srcSet = src_set.handle();
973 copy.srcBinding = src_binding;
974 copy.srcArrayElement = src_array_element;
975 copy.dstSet = dst_set.handle();
976 copy.dstBinding = dst_binding;
977 copy.dstArrayElement = dst_array_element;
978 copy.descriptorCount = count;
983 inline VkCommandBufferAllocateInfo CommandBuffer::create_info(VkCommandPool const &pool) {
984 VkCommandBufferAllocateInfo info = {};
985 info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
986 info.commandPool = pool;
987 info.commandBufferCount = 1;
991 } // namespace vk_testing
993 #endif // VKTESTBINDING_H