1 /*
2 * Copyright (c) 2015-2016, 2020 The Khronos Group Inc.
3 * Copyright (c) 2015-2016, 2020 Valve Corporation
4 * Copyright (c) 2015-2016, 2020 LunarG, Inc.
5 *
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
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
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.
17 *
18 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
19 * Author: Cody Northrop <cody@lunarg.com>
20 * Author: John Zulauf <jzulauf@lunarg.com>
21 */
22
23 #ifndef VKTESTBINDING_H
24 #define VKTESTBINDING_H
25
26 #include <algorithm>
27 #include <cassert>
28 #include <iterator>
29 #include <memory>
30 #include <vector>
31
32 #include "lvt_function_pointers.h"
33 #include "test_common.h"
34
35 namespace vk_testing {
36
37 template <class Dst, class Src>
MakeVkHandles(const std::vector<Src> & v)38 std::vector<Dst> MakeVkHandles(const std::vector<Src> &v) {
39 std::vector<Dst> handles;
40 handles.reserve(v.size());
41 std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src &o) { return o.handle(); });
42 return handles;
43 }
44
45 template <class Dst, class Src>
MakeVkHandles(const std::vector<Src * > & v)46 std::vector<Dst> MakeVkHandles(const std::vector<Src *> &v) {
47 std::vector<Dst> handles;
48 handles.reserve(v.size());
49 std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src *o) { return o->handle(); });
50 return handles;
51 }
52
53 typedef void (*ErrorCallback)(const char *expr, const char *file, unsigned int line, const char *function);
54 void set_error_callback(ErrorCallback callback);
55
56 class PhysicalDevice;
57 class Device;
58 class Queue;
59 class DeviceMemory;
60 class Fence;
61 class Semaphore;
62 class Event;
63 class QueryPool;
64 class Buffer;
65 class BufferView;
66 class Image;
67 class ImageView;
68 class DepthStencilView;
69 class Shader;
70 class Pipeline;
71 class PipelineDelta;
72 class Sampler;
73 class DescriptorSetLayout;
74 class PipelineLayout;
75 class DescriptorSetPool;
76 class DescriptorSet;
77 class CommandBuffer;
78 class CommandPool;
79
80 std::vector<VkLayerProperties> GetGlobalLayers();
81 std::vector<VkExtensionProperties> GetGlobalExtensions();
82 std::vector<VkExtensionProperties> GetGlobalExtensions(const char *pLayerName);
83
84 namespace internal {
85
86 template <typename T>
87 class Handle {
88 public:
handle()89 const T &handle() const NOEXCEPT { return handle_; }
initialized()90 bool initialized() const NOEXCEPT { return (handle_ != T{}); }
91
92 protected:
93 typedef T handle_type;
94
Handle()95 explicit Handle() NOEXCEPT : handle_{} {}
Handle(T handle)96 explicit Handle(T handle) NOEXCEPT : handle_(handle) {}
97
98 // handles are non-copyable
99 Handle(const Handle &) = delete;
100 Handle &operator=(const Handle &) = delete;
101
102 // handles can be moved out
Handle(Handle && src)103 Handle(Handle &&src) NOEXCEPT : handle_{src.handle_} { src.handle_ = {}; }
104 Handle &operator=(Handle &&src) NOEXCEPT {
105 handle_ = src.handle_;
106 src.handle_ = {};
107 return *this;
108 }
109
init(T handle)110 void init(T handle) NOEXCEPT {
111 assert(!initialized());
112 handle_ = handle;
113 }
114
115 private:
116 T handle_;
117 };
118
119 template <typename T>
120 class NonDispHandle : public Handle<T> {
121 protected:
NonDispHandle()122 explicit NonDispHandle() NOEXCEPT : Handle<T>(), dev_handle_(VK_NULL_HANDLE) {}
NonDispHandle(VkDevice dev,T handle)123 explicit NonDispHandle(VkDevice dev, T handle) NOEXCEPT : Handle<T>(handle), dev_handle_(dev) {}
124
NonDispHandle(NonDispHandle && src)125 NonDispHandle(NonDispHandle &&src) NOEXCEPT : Handle<T>(std::move(src)) {
126 dev_handle_ = src.dev_handle_;
127 src.dev_handle_ = VK_NULL_HANDLE;
128 }
129 NonDispHandle &operator=(NonDispHandle &&src) NOEXCEPT {
130 Handle<T>::operator=(std::move(src));
131 dev_handle_ = src.dev_handle_;
132 src.dev_handle_ = VK_NULL_HANDLE;
133 return *this;
134 }
135
device()136 const VkDevice &device() const NOEXCEPT { return dev_handle_; }
137
init(VkDevice dev,T handle)138 void init(VkDevice dev, T handle) NOEXCEPT {
139 assert(!Handle<T>::initialized() && dev_handle_ == VK_NULL_HANDLE);
140 Handle<T>::init(handle);
141 dev_handle_ = dev;
142 }
143
144 private:
145 VkDevice dev_handle_;
146 };
147
148 } // namespace internal
149
150 class PhysicalDevice : public internal::Handle<VkPhysicalDevice> {
151 public:
PhysicalDevice(VkPhysicalDevice phy)152 explicit PhysicalDevice(VkPhysicalDevice phy) : Handle(phy) {
153 memory_properties_ = memory_properties();
154 device_properties_ = properties();
155 }
156
157 VkPhysicalDeviceProperties properties() const;
158 VkPhysicalDeviceMemoryProperties memory_properties() const;
159 std::vector<VkQueueFamilyProperties> queue_properties() const;
160 VkPhysicalDeviceFeatures features() const;
161
162 bool set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkMemoryPropertyFlags properties,
163 const VkMemoryPropertyFlags forbid = 0) const;
164
165 // vkEnumerateDeviceExtensionProperties()
166 std::vector<VkExtensionProperties> extensions(const char *pLayerName = nullptr) const;
167
168 // vkEnumerateLayers()
169 std::vector<VkLayerProperties> layers() const;
170
171 private:
172 void add_extension_dependencies(uint32_t dependency_count, VkExtensionProperties *depencency_props,
173 std::vector<VkExtensionProperties> &ext_list);
174
175 VkPhysicalDeviceMemoryProperties memory_properties_;
176
177 VkPhysicalDeviceProperties device_properties_;
178 };
179
180 class QueueCreateInfoArray {
181 private:
182 std::vector<VkDeviceQueueCreateInfo> queue_info_;
183 std::vector<std::vector<float>> queue_priorities_;
184
185 public:
186 QueueCreateInfoArray(const std::vector<VkQueueFamilyProperties> &queue_props);
size()187 size_t size() const { return queue_info_.size(); }
data()188 const VkDeviceQueueCreateInfo *data() const { return queue_info_.data(); }
189 };
190
191 class Device : public internal::Handle<VkDevice> {
192 public:
Device(VkPhysicalDevice phy)193 explicit Device(VkPhysicalDevice phy) : phy_(phy) {}
194 ~Device() NOEXCEPT;
195
196 // vkCreateDevice()
197 void init(const VkDeviceCreateInfo &info);
198 void init(std::vector<const char *> &extensions, VkPhysicalDeviceFeatures *features = nullptr,
199 void *create_device_pnext = nullptr); // all queues, all extensions, etc
init()200 void init() {
201 std::vector<const char *> extensions;
202 init(extensions);
203 };
204
phy()205 const PhysicalDevice &phy() const { return phy_; }
206
GetEnabledExtensions()207 std::vector<const char *> GetEnabledExtensions() { return enabled_extensions_; }
208 bool IsEnabledExtension(const char *extension);
209
210 // vkGetDeviceProcAddr()
get_proc(const char * name)211 PFN_vkVoidFunction get_proc(const char *name) const { return vk::GetDeviceProcAddr(handle(), name); }
212
213 // vkGetDeviceQueue()
graphics_queues()214 const std::vector<Queue *> &graphics_queues() const { return queues_[GRAPHICS]; }
compute_queues()215 const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; }
dma_queues()216 const std::vector<Queue *> &dma_queues() { return queues_[DMA]; }
217
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;
221
222 uint32_t graphics_queue_node_index_;
223
224 struct Format {
225 VkFormat format;
226 VkImageTiling tiling;
227 VkFlags features;
228 };
229 // vkGetFormatInfo()
230 VkFormatProperties format_properties(VkFormat format);
formats()231 const std::vector<Format> &formats() const { return formats_; }
232
233 // vkDeviceWaitIdle()
234 void wait();
235
236 // vkWaitForFences()
237 VkResult wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout);
wait(const Fence & fence)238 VkResult wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t)-1); }
239
240 // vkUpdateDescriptorSets()
241 void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies);
update_descriptor_sets(const std::vector<VkWriteDescriptorSet> & writes)242 void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes) {
243 return update_descriptor_sets(writes, std::vector<VkCopyDescriptorSet>());
244 }
245
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);
260
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,
263 uint32_t count);
264
265 private:
266 enum QueueIndex {
267 GRAPHICS,
268 COMPUTE,
269 DMA,
270 QUEUE_COUNT,
271 };
272
273 void init_queues();
274 void init_formats();
275
276 PhysicalDevice phy_;
277
278 std::vector<const char *> enabled_extensions_;
279
280 QueueFamilies queue_families_;
281 std::vector<Queue *> queues_[QUEUE_COUNT];
282 std::vector<Format> formats_;
283 };
284
285 class Queue : public internal::Handle<VkQueue> {
286 public:
Queue(VkQueue queue,int index)287 explicit Queue(VkQueue queue, int index) : Handle(queue) { family_index_ = index; }
288
289 // vkQueueSubmit()
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);
293
294 // vkQueueWaitIdle()
295 VkResult wait();
296
get_family_index()297 int get_family_index() { return family_index_; }
298
299 private:
300 int family_index_;
301 };
302
303 class DeviceMemory : public internal::NonDispHandle<VkDeviceMemory> {
304 public:
305 ~DeviceMemory() NOEXCEPT;
306
307 // vkAllocateMemory()
308 void init(const Device &dev, const VkMemoryAllocateInfo &info);
309
310 // vkMapMemory()
311 const void *map(VkFlags flags) const;
312 void *map(VkFlags flags);
map()313 const void *map() const { return map(0); }
map()314 void *map() { return map(0); }
315
316 // vkUnmapMemory()
317 void unmap() const;
318
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);
322 };
323
324 class Fence : public internal::NonDispHandle<VkFence> {
325 public:
326 ~Fence() NOEXCEPT;
327
328 // vkCreateFence()
329 void init(const Device &dev, const VkFenceCreateInfo &info);
330
331 // vkGetFenceStatus()
status()332 VkResult status() const { return vk::GetFenceStatus(device(), handle()); }
333 VkResult wait(uint64_t timeout) const;
334
335 static VkFenceCreateInfo create_info(VkFenceCreateFlags flags);
336 static VkFenceCreateInfo create_info();
337 };
338
339 class Semaphore : public internal::NonDispHandle<VkSemaphore> {
340 public:
341 ~Semaphore() NOEXCEPT;
342
343 // vkCreateSemaphore()
344 void init(const Device &dev, const VkSemaphoreCreateInfo &info);
345
346 static VkSemaphoreCreateInfo create_info(VkFlags flags);
347 };
348
349 class Event : public internal::NonDispHandle<VkEvent> {
350 public:
351 ~Event() NOEXCEPT;
352
353 // vkCreateEvent()
354 void init(const Device &dev, const VkEventCreateInfo &info);
355
356 // vkGetEventStatus()
357 // vkSetEvent()
358 // vkResetEvent()
status()359 VkResult status() const { return vk::GetEventStatus(device(), handle()); }
360 void set();
361 void reset();
362
363 static VkEventCreateInfo create_info(VkFlags flags);
364 };
365
366 class QueryPool : public internal::NonDispHandle<VkQueryPool> {
367 public:
368 ~QueryPool() NOEXCEPT;
369
370 // vkCreateQueryPool()
371 void init(const Device &dev, const VkQueryPoolCreateInfo &info);
372
373 // vkGetQueryPoolResults()
374 VkResult results(uint32_t first, uint32_t count, size_t size, void *data, size_t stride);
375
376 static VkQueryPoolCreateInfo create_info(VkQueryType type, uint32_t slot_count);
377 };
378
379 class Buffer : public internal::NonDispHandle<VkBuffer> {
380 public:
Buffer()381 explicit Buffer() : NonDispHandle() {}
Buffer(const Device & dev,const VkBufferCreateInfo & info)382 explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); }
Buffer(const Device & dev,VkDeviceSize size)383 explicit Buffer(const Device &dev, VkDeviceSize size) { init(dev, size); }
384
385 ~Buffer() NOEXCEPT;
386
387 // vkCreateBuffer()
388 void init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props);
init(const Device & dev,const VkBufferCreateInfo & info)389 void init(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info, 0); }
390 void init(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags mem_props,
391 VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, const std::vector<uint32_t> &queue_families = {}) {
392 init(dev, create_info(size, usage, &queue_families), mem_props);
393 }
init(const Device & dev,VkDeviceSize size)394 void init(const Device &dev, VkDeviceSize size) { init(dev, size, 0); }
395 void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
396 const std::vector<uint32_t> *queue_families = nullptr) {
397 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, queue_families), reqs);
398 }
399 void init_as_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
400 const std::vector<uint32_t> *queue_families = nullptr) {
401 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs);
402 }
403 void init_as_src_and_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
404 const std::vector<uint32_t> *queue_families = nullptr, bool memory = true) {
405 if (memory)
406 init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families), reqs);
407 else
408 init_no_mem(dev,
409 create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, queue_families));
410 }
411 void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
412
413 // get the internal memory
memory()414 const DeviceMemory &memory() const { return internal_mem_; }
memory()415 DeviceMemory &memory() { return internal_mem_; }
416
417 // vkGetObjectMemoryRequirements()
418 VkMemoryRequirements memory_requirements() const;
419
420 // vkBindObjectMemory()
421 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
422
create_info()423 const VkBufferCreateInfo &create_info() const { return create_info_; }
424 static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families = nullptr);
425
buffer_memory_barrier(VkFlags output_mask,VkFlags input_mask,VkDeviceSize offset,VkDeviceSize size)426 VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkDeviceSize offset,
427 VkDeviceSize size) const {
428 VkBufferMemoryBarrier barrier = {};
429 barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
430 barrier.buffer = handle();
431 barrier.srcAccessMask = output_mask;
432 barrier.dstAccessMask = input_mask;
433 barrier.offset = offset;
434 barrier.size = size;
435 if (create_info_.sharingMode == VK_SHARING_MODE_CONCURRENT) {
436 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
437 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
438 }
439 return barrier;
440 }
441
442 private:
443 VkBufferCreateInfo create_info_;
444
445 DeviceMemory internal_mem_;
446 };
447
448 class BufferView : public internal::NonDispHandle<VkBufferView> {
449 public:
450 ~BufferView() NOEXCEPT;
451
452 // vkCreateBufferView()
453 void init(const Device &dev, const VkBufferViewCreateInfo &info);
454 static VkBufferViewCreateInfo createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset = 0,
455 VkDeviceSize range = VK_WHOLE_SIZE);
456 };
457
createInfo(VkBuffer buffer,VkFormat format,VkDeviceSize offset,VkDeviceSize range)458 inline VkBufferViewCreateInfo BufferView::createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset, VkDeviceSize range) {
459 VkBufferViewCreateInfo info = {};
460 info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
461 info.pNext = nullptr;
462 info.flags = VkFlags(0);
463 info.buffer = buffer;
464 info.format = format;
465 info.offset = offset;
466 info.range = range;
467 return info;
468 }
469
470 class Image : public internal::NonDispHandle<VkImage> {
471 public:
Image()472 explicit Image() : NonDispHandle(), format_features_(0) {}
Image(const Device & dev,const VkImageCreateInfo & info)473 explicit Image(const Device &dev, const VkImageCreateInfo &info) : format_features_(0) { init(dev, info); }
474
475 ~Image() NOEXCEPT;
476
477 // vkCreateImage()
478 void init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props);
init(const Device & dev,const VkImageCreateInfo & info)479 void init(const Device &dev, const VkImageCreateInfo &info) { init(dev, info, 0); }
480 void init_no_mem(const Device &dev, const VkImageCreateInfo &info);
481
482 // get the internal memory
memory()483 const DeviceMemory &memory() const { return internal_mem_; }
memory()484 DeviceMemory &memory() { return internal_mem_; }
485
486 // vkGetObjectMemoryRequirements()
487 VkMemoryRequirements memory_requirements() const;
488
489 // vkBindObjectMemory()
490 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
491
492 // vkGetImageSubresourceLayout()
493 VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const;
494 VkSubresourceLayout subresource_layout(const VkImageSubresourceLayers &subres) const;
495
496 bool transparent() const;
copyable()497 bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); }
498
subresource_range(VkImageAspectFlags aspect)499 VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect) const { return subresource_range(create_info_, aspect); }
extent()500 VkExtent3D extent() const { return create_info_.extent; }
extent(uint32_t mip_level)501 VkExtent3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); }
format()502 VkFormat format() const { return create_info_.format; }
usage()503 VkImageUsageFlags usage() const { return create_info_.usage; }
sharing_mode()504 VkSharingMode sharing_mode() const { return create_info_.sharingMode; }
505 VkImageMemoryBarrier image_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkImageLayout old_layout,
506 VkImageLayout new_layout, const VkImageSubresourceRange &range,
507 uint32_t srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
508 uint32_t dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED) const {
509 VkImageMemoryBarrier barrier = {};
510 barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
511 barrier.srcAccessMask = output_mask;
512 barrier.dstAccessMask = input_mask;
513 barrier.oldLayout = old_layout;
514 barrier.newLayout = new_layout;
515 barrier.image = handle();
516 barrier.subresourceRange = range;
517 barrier.srcQueueFamilyIndex = srcQueueFamilyIndex;
518 barrier.dstQueueFamilyIndex = dstQueueFamilyIndex;
519 return barrier;
520 }
521
522 static VkImageCreateInfo create_info();
523 static VkImageSubresource subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer);
524 static VkImageSubresource subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer);
525 static VkImageSubresourceLayers subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
526 uint32_t array_size);
527 static VkImageSubresourceLayers subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
528 uint32_t array_size);
529 static VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, uint32_t mip_levels,
530 uint32_t base_array_layer, uint32_t num_layers);
531 static VkImageSubresourceRange subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask);
532 static VkImageSubresourceRange subresource_range(const VkImageSubresource &subres);
533
534 static VkExtent2D extent(int32_t width, int32_t height);
535 static VkExtent2D extent(const VkExtent2D &extent, uint32_t mip_level);
536 static VkExtent2D extent(const VkExtent3D &extent);
537
538 static VkExtent3D extent(int32_t width, int32_t height, int32_t depth);
539 static VkExtent3D extent(const VkExtent3D &extent, uint32_t mip_level);
540
541 private:
542 void init_info(const Device &dev, const VkImageCreateInfo &info);
543
544 VkImageCreateInfo create_info_;
545 VkFlags format_features_;
546
547 DeviceMemory internal_mem_;
548 };
549
550 class ImageView : public internal::NonDispHandle<VkImageView> {
551 public:
552 ~ImageView() NOEXCEPT;
553
554 // vkCreateImageView()
555 void init(const Device &dev, const VkImageViewCreateInfo &info);
556 };
557
558 class AccelerationStructure : public internal::NonDispHandle<VkAccelerationStructureNV> {
559 public:
560 explicit AccelerationStructure(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true) {
561 init(dev, info, init_memory);
562 isKHR = false;
563 }
564 explicit AccelerationStructure(const Device &dev, const VkAccelerationStructureCreateInfoKHR &info, bool init_memory = true) {
565 initKHR(dev, info, init_memory);
566 isKHR = true;
567 }
568 ~AccelerationStructure();
569
570 // vkCreateAccelerationStructureNV
571 void init(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true);
572 void initKHR(const Device &dev, const VkAccelerationStructureCreateInfoKHR &info, bool init_memory = true);
573 // vkGetAccelerationStructureMemoryRequirementsNV()
574 VkMemoryRequirements2 memory_requirements(bool isKHR = false) const;
575 VkMemoryRequirements2 build_scratch_memory_requirements() const;
576
opaque_handle()577 uint64_t opaque_handle() const { return opaque_handle_; }
578
info()579 const VkAccelerationStructureInfoNV &info() const { return info_; }
580
dev()581 const VkDevice &dev() const { return device(); }
582
583 void create_scratch_buffer(const Device &dev, Buffer *buffer, VkBufferCreateInfo *pCreateInfo = NULL);
584
585 private:
586 VkAccelerationStructureInfoNV info_;
587 DeviceMemory memory_;
588 uint64_t opaque_handle_;
589 bool isKHR;
590 };
591
592 class ShaderModule : public internal::NonDispHandle<VkShaderModule> {
593 public:
594 ~ShaderModule() NOEXCEPT;
595
596 // vkCreateShaderModule()
597 void init(const Device &dev, const VkShaderModuleCreateInfo &info);
598 VkResult init_try(const Device &dev, const VkShaderModuleCreateInfo &info);
599
600 static VkShaderModuleCreateInfo create_info(size_t code_size, const uint32_t *code, VkFlags flags);
601 };
602
603 class Pipeline : public internal::NonDispHandle<VkPipeline> {
604 public:
605 ~Pipeline() NOEXCEPT;
606
607 // vkCreateGraphicsPipeline()
608 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
609 // vkCreateGraphicsPipelineDerivative()
610 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info, const VkPipeline basePipeline);
611 // vkCreateComputePipeline()
612 void init(const Device &dev, const VkComputePipelineCreateInfo &info);
613 // vkLoadPipeline()
614 void init(const Device &dev, size_t size, const void *data);
615 // vkLoadPipelineDerivative()
616 void init(const Device &dev, size_t size, const void *data, VkPipeline basePipeline);
617
618 // vkCreateGraphicsPipeline with error return
619 VkResult init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
620
621 // vkStorePipeline()
622 size_t store(size_t size, void *data);
623 };
624
625 class PipelineLayout : public internal::NonDispHandle<VkPipelineLayout> {
626 public:
PipelineLayout()627 PipelineLayout() NOEXCEPT : NonDispHandle() {}
628 ~PipelineLayout() NOEXCEPT;
629
630 // Move constructor for Visual Studio 2013
PipelineLayout(PipelineLayout && src)631 PipelineLayout(PipelineLayout &&src) NOEXCEPT : NonDispHandle(std::move(src)){};
632
633 PipelineLayout &operator=(PipelineLayout &&src) NOEXCEPT {
634 this->~PipelineLayout();
635 this->NonDispHandle::operator=(std::move(src));
636 return *this;
637 };
638
639 // vCreatePipelineLayout()
640 void init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts);
641 };
642
643 class Sampler : public internal::NonDispHandle<VkSampler> {
644 public:
645 ~Sampler() NOEXCEPT;
646
647 // vkCreateSampler()
648 void init(const Device &dev, const VkSamplerCreateInfo &info);
649 };
650
651 class DescriptorSetLayout : public internal::NonDispHandle<VkDescriptorSetLayout> {
652 public:
DescriptorSetLayout()653 DescriptorSetLayout() NOEXCEPT : NonDispHandle(){};
654 ~DescriptorSetLayout() NOEXCEPT;
655
656 // Move constructor for Visual Studio 2013
DescriptorSetLayout(DescriptorSetLayout && src)657 DescriptorSetLayout(DescriptorSetLayout &&src) NOEXCEPT : NonDispHandle(std::move(src)){};
658
659 DescriptorSetLayout &operator=(DescriptorSetLayout &&src) NOEXCEPT {
660 this->~DescriptorSetLayout();
661 this->NonDispHandle::operator=(std::move(src));
662 return *this;
663 }
664
665 // vkCreateDescriptorSetLayout()
666 void init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info);
667 };
668
669 class DescriptorPool : public internal::NonDispHandle<VkDescriptorPool> {
670 public:
671 ~DescriptorPool() NOEXCEPT;
672
673 // Descriptor sets allocated from this pool will need access to the original
674 // object
GetObj()675 VkDescriptorPool GetObj() { return pool_; }
676
677 // vkCreateDescriptorPool()
678 void init(const Device &dev, const VkDescriptorPoolCreateInfo &info);
679
680 // vkResetDescriptorPool()
681 void reset();
682
683 // vkFreeDescriptorSet()
setDynamicUsage(bool isDynamic)684 void setDynamicUsage(bool isDynamic) { dynamic_usage_ = isDynamic; }
getDynamicUsage()685 bool getDynamicUsage() { return dynamic_usage_; }
686
687 // vkAllocateDescriptorSets()
688 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
689 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count);
690 DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout);
691
692 template <typename PoolSizes>
693 static VkDescriptorPoolCreateInfo create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
694 const PoolSizes &pool_sizes);
695
696 private:
697 VkDescriptorPool pool_;
698
699 // Track whether this pool's usage is VK_DESCRIPTOR_POOL_USAGE_DYNAMIC
700 bool dynamic_usage_;
701 };
702
703 template <typename PoolSizes>
create_info(VkDescriptorPoolCreateFlags flags,uint32_t max_sets,const PoolSizes & pool_sizes)704 inline VkDescriptorPoolCreateInfo DescriptorPool::create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
705 const PoolSizes &pool_sizes) {
706 VkDescriptorPoolCreateInfo info{};
707 info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
708 info.pNext = nullptr;
709 info.flags = flags;
710 info.maxSets = max_sets;
711 info.poolSizeCount = pool_sizes.size();
712 info.pPoolSizes = (info.poolSizeCount) ? pool_sizes.data() : nullptr;
713 return info;
714 }
715
716 class DescriptorSet : public internal::NonDispHandle<VkDescriptorSet> {
717 public:
718 ~DescriptorSet() NOEXCEPT;
719
DescriptorSet()720 explicit DescriptorSet() : NonDispHandle() {}
DescriptorSet(const Device & dev,DescriptorPool * pool,VkDescriptorSet set)721 explicit DescriptorSet(const Device &dev, DescriptorPool *pool, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) {
722 containing_pool_ = pool;
723 }
724
725 private:
726 DescriptorPool *containing_pool_;
727 };
728
729 class CommandPool : public internal::NonDispHandle<VkCommandPool> {
730 public:
731 ~CommandPool() NOEXCEPT;
732
CommandPool()733 explicit CommandPool() : NonDispHandle() {}
CommandPool(const Device & dev,const VkCommandPoolCreateInfo & info)734 explicit CommandPool(const Device &dev, const VkCommandPoolCreateInfo &info) { init(dev, info); }
735
736 void init(const Device &dev, const VkCommandPoolCreateInfo &info);
737
738 static VkCommandPoolCreateInfo create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags);
739 };
740
create_info(uint32_t queue_family_index,VkCommandPoolCreateFlags flags)741 inline VkCommandPoolCreateInfo CommandPool::create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags) {
742 VkCommandPoolCreateInfo info = {};
743 info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
744 info.queueFamilyIndex = queue_family_index;
745 info.flags = flags;
746 return info;
747 }
748
749 class CommandBuffer : public internal::Handle<VkCommandBuffer> {
750 public:
751 ~CommandBuffer() NOEXCEPT;
752
CommandBuffer()753 explicit CommandBuffer() : Handle() {}
CommandBuffer(const Device & dev,const VkCommandBufferAllocateInfo & info)754 explicit CommandBuffer(const Device &dev, const VkCommandBufferAllocateInfo &info) { init(dev, info); }
755
756 // vkAllocateCommandBuffers()
757 void init(const Device &dev, const VkCommandBufferAllocateInfo &info);
758
759 // vkBeginCommandBuffer()
760 void begin(const VkCommandBufferBeginInfo *info);
761 void begin();
762
763 // vkEndCommandBuffer()
764 // vkResetCommandBuffer()
765 void end();
766 void reset(VkCommandBufferResetFlags flags);
reset()767 void reset() { reset(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
768
769 static VkCommandBufferAllocateInfo create_info(VkCommandPool const &pool);
770
771 private:
772 VkDevice dev_handle_;
773 VkCommandPool cmd_pool_;
774 };
775
alloc_info(VkDeviceSize size,uint32_t memory_type_index)776 inline VkMemoryAllocateInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index) {
777 VkMemoryAllocateInfo info = {};
778 info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
779 info.allocationSize = size;
780 info.memoryTypeIndex = memory_type_index;
781 return info;
782 }
783
create_info(VkDeviceSize size,VkFlags usage,const std::vector<uint32_t> * queue_families)784 inline VkBufferCreateInfo Buffer::create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families) {
785 VkBufferCreateInfo info = {};
786 info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
787 info.size = size;
788 info.usage = usage;
789
790 if (queue_families && queue_families->size() > 1) {
791 info.sharingMode = VK_SHARING_MODE_CONCURRENT;
792 info.queueFamilyIndexCount = static_cast<uint32_t>(queue_families->size());
793 info.pQueueFamilyIndices = queue_families->data();
794 }
795
796 return info;
797 }
798
create_info(VkFenceCreateFlags flags)799 inline VkFenceCreateInfo Fence::create_info(VkFenceCreateFlags flags) {
800 VkFenceCreateInfo info = {};
801 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
802 info.flags = flags;
803 return info;
804 }
805
create_info()806 inline VkFenceCreateInfo Fence::create_info() {
807 VkFenceCreateInfo info = {};
808 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
809 return info;
810 }
811
create_info(VkFlags flags)812 inline VkSemaphoreCreateInfo Semaphore::create_info(VkFlags flags) {
813 VkSemaphoreCreateInfo info = {};
814 info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
815 info.flags = flags;
816 return info;
817 }
818
create_info(VkFlags flags)819 inline VkEventCreateInfo Event::create_info(VkFlags flags) {
820 VkEventCreateInfo info = {};
821 info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
822 info.flags = flags;
823 return info;
824 }
825
create_info(VkQueryType type,uint32_t slot_count)826 inline VkQueryPoolCreateInfo QueryPool::create_info(VkQueryType type, uint32_t slot_count) {
827 VkQueryPoolCreateInfo info = {};
828 info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
829 info.queryType = type;
830 info.queryCount = slot_count;
831 return info;
832 }
833
create_info()834 inline VkImageCreateInfo Image::create_info() {
835 VkImageCreateInfo info = {};
836 info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
837 info.extent.width = 1;
838 info.extent.height = 1;
839 info.extent.depth = 1;
840 info.mipLevels = 1;
841 info.arrayLayers = 1;
842 info.samples = VK_SAMPLE_COUNT_1_BIT;
843 return info;
844 }
845
subresource(VkImageAspectFlags aspect,uint32_t mip_level,uint32_t array_layer)846 inline VkImageSubresource Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer) {
847 VkImageSubresource subres = {};
848 if (aspect == 0) {
849 assert(!"Invalid VkImageAspectFlags");
850 }
851 subres.aspectMask = aspect;
852 subres.mipLevel = mip_level;
853 subres.arrayLayer = array_layer;
854 return subres;
855 }
856
subresource(const VkImageSubresourceRange & range,uint32_t mip_level,uint32_t array_layer)857 inline VkImageSubresource Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer) {
858 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer);
859 }
860
subresource(VkImageAspectFlags aspect,uint32_t mip_level,uint32_t array_layer,uint32_t array_size)861 inline VkImageSubresourceLayers Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
862 uint32_t array_size) {
863 VkImageSubresourceLayers subres = {};
864 switch (aspect) {
865 case VK_IMAGE_ASPECT_COLOR_BIT:
866 case VK_IMAGE_ASPECT_DEPTH_BIT:
867 case VK_IMAGE_ASPECT_STENCIL_BIT:
868 case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT:
869 /* valid */
870 break;
871 default:
872 assert(!"Invalid VkImageAspectFlags");
873 }
874 subres.aspectMask = aspect;
875 subres.mipLevel = mip_level;
876 subres.baseArrayLayer = array_layer;
877 subres.layerCount = array_size;
878 return subres;
879 }
880
subresource(const VkImageSubresourceRange & range,uint32_t mip_level,uint32_t array_layer,uint32_t array_size)881 inline VkImageSubresourceLayers Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
882 uint32_t array_size) {
883 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer, array_size);
884 }
885
subresource_range(VkImageAspectFlags aspect_mask,uint32_t base_mip_level,uint32_t mip_levels,uint32_t base_array_layer,uint32_t num_layers)886 inline VkImageSubresourceRange Image::subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level,
887 uint32_t mip_levels, uint32_t base_array_layer, uint32_t num_layers) {
888 VkImageSubresourceRange range = {};
889 if (aspect_mask == 0) {
890 assert(!"Invalid VkImageAspectFlags");
891 }
892 range.aspectMask = aspect_mask;
893 range.baseMipLevel = base_mip_level;
894 range.levelCount = mip_levels;
895 range.baseArrayLayer = base_array_layer;
896 range.layerCount = num_layers;
897 return range;
898 }
899
subresource_range(const VkImageCreateInfo & info,VkImageAspectFlags aspect_mask)900 inline VkImageSubresourceRange Image::subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask) {
901 return subresource_range(aspect_mask, 0, info.mipLevels, 0, info.arrayLayers);
902 }
903
subresource_range(const VkImageSubresource & subres)904 inline VkImageSubresourceRange Image::subresource_range(const VkImageSubresource &subres) {
905 return subresource_range(subres.aspectMask, subres.mipLevel, 1, subres.arrayLayer, 1);
906 }
907
extent(int32_t width,int32_t height)908 inline VkExtent2D Image::extent(int32_t width, int32_t height) {
909 VkExtent2D extent = {};
910 extent.width = width;
911 extent.height = height;
912 return extent;
913 }
914
extent(const VkExtent2D & extent,uint32_t mip_level)915 inline VkExtent2D Image::extent(const VkExtent2D &extent, uint32_t mip_level) {
916 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
917 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
918 return Image::extent(width, height);
919 }
920
extent(const VkExtent3D & extent)921 inline VkExtent2D Image::extent(const VkExtent3D &extent) { return Image::extent(extent.width, extent.height); }
922
extent(int32_t width,int32_t height,int32_t depth)923 inline VkExtent3D Image::extent(int32_t width, int32_t height, int32_t depth) {
924 VkExtent3D extent = {};
925 extent.width = width;
926 extent.height = height;
927 extent.depth = depth;
928 return extent;
929 }
930
extent(const VkExtent3D & extent,uint32_t mip_level)931 inline VkExtent3D Image::extent(const VkExtent3D &extent, uint32_t mip_level) {
932 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
933 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
934 const int32_t depth = (extent.depth >> mip_level) ? extent.depth >> mip_level : 1;
935 return Image::extent(width, height, depth);
936 }
937
create_info(size_t code_size,const uint32_t * code,VkFlags flags)938 inline VkShaderModuleCreateInfo ShaderModule::create_info(size_t code_size, const uint32_t *code, VkFlags flags) {
939 VkShaderModuleCreateInfo info = {};
940 info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
941 info.codeSize = code_size;
942 info.pCode = code;
943 info.flags = flags;
944 return info;
945 }
946
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkDescriptorImageInfo * image_info)947 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
948 VkDescriptorType type, uint32_t count,
949 const VkDescriptorImageInfo *image_info) {
950 VkWriteDescriptorSet write = {};
951 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
952 write.dstSet = set.handle();
953 write.dstBinding = binding;
954 write.dstArrayElement = array_element;
955 write.descriptorCount = count;
956 write.descriptorType = type;
957 write.pImageInfo = image_info;
958 return write;
959 }
960
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkDescriptorBufferInfo * buffer_info)961 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
962 VkDescriptorType type, uint32_t count,
963 const VkDescriptorBufferInfo *buffer_info) {
964 VkWriteDescriptorSet write = {};
965 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
966 write.dstSet = set.handle();
967 write.dstBinding = binding;
968 write.dstArrayElement = array_element;
969 write.descriptorCount = count;
970 write.descriptorType = type;
971 write.pBufferInfo = buffer_info;
972 return write;
973 }
974
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkBufferView * buffer_views)975 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
976 VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views) {
977 VkWriteDescriptorSet write = {};
978 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
979 write.dstSet = set.handle();
980 write.dstBinding = binding;
981 write.dstArrayElement = array_element;
982 write.descriptorCount = count;
983 write.descriptorType = type;
984 write.pTexelBufferView = buffer_views;
985 return write;
986 }
987
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkDescriptorImageInfo> & image_info)988 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
989 VkDescriptorType type,
990 const std::vector<VkDescriptorImageInfo> &image_info) {
991 return write_descriptor_set(set, binding, array_element, type, image_info.size(), &image_info[0]);
992 }
993
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkDescriptorBufferInfo> & buffer_info)994 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
995 VkDescriptorType type,
996 const std::vector<VkDescriptorBufferInfo> &buffer_info) {
997 return write_descriptor_set(set, binding, array_element, type, buffer_info.size(), &buffer_info[0]);
998 }
999
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkBufferView> & buffer_views)1000 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
1001 VkDescriptorType type, const std::vector<VkBufferView> &buffer_views) {
1002 return write_descriptor_set(set, binding, array_element, type, buffer_views.size(), &buffer_views[0]);
1003 }
1004
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)1005 inline VkCopyDescriptorSet Device::copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding,
1006 uint32_t src_array_element, const DescriptorSet &dst_set,
1007 uint32_t dst_binding, uint32_t dst_array_element, uint32_t count) {
1008 VkCopyDescriptorSet copy = {};
1009 copy.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
1010 copy.srcSet = src_set.handle();
1011 copy.srcBinding = src_binding;
1012 copy.srcArrayElement = src_array_element;
1013 copy.dstSet = dst_set.handle();
1014 copy.dstBinding = dst_binding;
1015 copy.dstArrayElement = dst_array_element;
1016 copy.descriptorCount = count;
1017
1018 return copy;
1019 }
1020
create_info(VkCommandPool const & pool)1021 inline VkCommandBufferAllocateInfo CommandBuffer::create_info(VkCommandPool const &pool) {
1022 VkCommandBufferAllocateInfo info = {};
1023 info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
1024 info.commandPool = pool;
1025 info.commandBufferCount = 1;
1026 return info;
1027 }
1028
1029 } // namespace vk_testing
1030
1031 #endif // VKTESTBINDING_H
1032