1 /*
2 * Copyright (c) 2015-2016, 2020-2021 The Khronos Group Inc.
3 * Copyright (c) 2015-2016, 2020-2021 Valve Corporation
4 * Copyright (c) 2015-2016, 2020-2021 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_as_storage(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
412 const std::vector<uint32_t> *queue_families = nullptr) {
413 init(dev, create_info(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, queue_families), reqs);
414 }
415
416 void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
417
418 // get the internal memory
memory()419 const DeviceMemory &memory() const { return internal_mem_; }
memory()420 DeviceMemory &memory() { return internal_mem_; }
421
422 // vkGetObjectMemoryRequirements()
423 VkMemoryRequirements memory_requirements() const;
424
425 // vkBindObjectMemory()
426 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
427
create_info()428 const VkBufferCreateInfo &create_info() const { return create_info_; }
429 static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families = nullptr);
430
buffer_memory_barrier(VkFlags output_mask,VkFlags input_mask,VkDeviceSize offset,VkDeviceSize size)431 VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkDeviceSize offset,
432 VkDeviceSize size) const {
433 VkBufferMemoryBarrier barrier = {};
434 barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
435 barrier.buffer = handle();
436 barrier.srcAccessMask = output_mask;
437 barrier.dstAccessMask = input_mask;
438 barrier.offset = offset;
439 barrier.size = size;
440 if (create_info_.sharingMode == VK_SHARING_MODE_CONCURRENT) {
441 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
442 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
443 }
444 return barrier;
445 }
446
447 private:
448 VkBufferCreateInfo create_info_;
449
450 DeviceMemory internal_mem_;
451 };
452
453 class BufferView : public internal::NonDispHandle<VkBufferView> {
454 public:
455 ~BufferView() NOEXCEPT;
456
457 // vkCreateBufferView()
458 void init(const Device &dev, const VkBufferViewCreateInfo &info);
459 static VkBufferViewCreateInfo createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset = 0,
460 VkDeviceSize range = VK_WHOLE_SIZE);
461 };
462
createInfo(VkBuffer buffer,VkFormat format,VkDeviceSize offset,VkDeviceSize range)463 inline VkBufferViewCreateInfo BufferView::createInfo(VkBuffer buffer, VkFormat format, VkDeviceSize offset, VkDeviceSize range) {
464 VkBufferViewCreateInfo info = {};
465 info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
466 info.pNext = nullptr;
467 info.flags = VkFlags(0);
468 info.buffer = buffer;
469 info.format = format;
470 info.offset = offset;
471 info.range = range;
472 return info;
473 }
474
475 class Image : public internal::NonDispHandle<VkImage> {
476 public:
Image()477 explicit Image() : NonDispHandle(), format_features_(0) {}
Image(const Device & dev,const VkImageCreateInfo & info)478 explicit Image(const Device &dev, const VkImageCreateInfo &info) : format_features_(0) { init(dev, info); }
479
480 ~Image() NOEXCEPT;
481
482 // vkCreateImage()
483 void init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props);
init(const Device & dev,const VkImageCreateInfo & info)484 void init(const Device &dev, const VkImageCreateInfo &info) { init(dev, info, 0); }
485 void init_no_mem(const Device &dev, const VkImageCreateInfo &info);
486
487 // get the internal memory
memory()488 const DeviceMemory &memory() const { return internal_mem_; }
memory()489 DeviceMemory &memory() { return internal_mem_; }
490
491 // vkGetObjectMemoryRequirements()
492 VkMemoryRequirements memory_requirements() const;
493
494 // vkBindObjectMemory()
495 void bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset);
496
497 // vkGetImageSubresourceLayout()
498 VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const;
499 VkSubresourceLayout subresource_layout(const VkImageSubresourceLayers &subres) const;
500
501 bool transparent() const;
copyable()502 bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); }
503
subresource_range(VkImageAspectFlags aspect)504 VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect) const { return subresource_range(create_info_, aspect); }
extent()505 VkExtent3D extent() const { return create_info_.extent; }
extent(uint32_t mip_level)506 VkExtent3D extent(uint32_t mip_level) const { return extent(create_info_.extent, mip_level); }
format()507 VkFormat format() const { return create_info_.format; }
usage()508 VkImageUsageFlags usage() const { return create_info_.usage; }
sharing_mode()509 VkSharingMode sharing_mode() const { return create_info_.sharingMode; }
510 VkImageMemoryBarrier image_memory_barrier(VkFlags output_mask, VkFlags input_mask, VkImageLayout old_layout,
511 VkImageLayout new_layout, const VkImageSubresourceRange &range,
512 uint32_t srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
513 uint32_t dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED) const {
514 VkImageMemoryBarrier barrier = {};
515 barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
516 barrier.srcAccessMask = output_mask;
517 barrier.dstAccessMask = input_mask;
518 barrier.oldLayout = old_layout;
519 barrier.newLayout = new_layout;
520 barrier.image = handle();
521 barrier.subresourceRange = range;
522 barrier.srcQueueFamilyIndex = srcQueueFamilyIndex;
523 barrier.dstQueueFamilyIndex = dstQueueFamilyIndex;
524 return barrier;
525 }
526
527 static VkImageCreateInfo create_info();
528 static VkImageSubresource subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer);
529 static VkImageSubresource subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer);
530 static VkImageSubresourceLayers subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
531 uint32_t array_size);
532 static VkImageSubresourceLayers subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
533 uint32_t array_size);
534 static VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, uint32_t mip_levels,
535 uint32_t base_array_layer, uint32_t num_layers);
536 static VkImageSubresourceRange subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask);
537 static VkImageSubresourceRange subresource_range(const VkImageSubresource &subres);
538
539 static VkExtent2D extent(int32_t width, int32_t height);
540 static VkExtent2D extent(const VkExtent2D &extent, uint32_t mip_level);
541 static VkExtent2D extent(const VkExtent3D &extent);
542
543 static VkExtent3D extent(int32_t width, int32_t height, int32_t depth);
544 static VkExtent3D extent(const VkExtent3D &extent, uint32_t mip_level);
545
546 private:
547 void init_info(const Device &dev, const VkImageCreateInfo &info);
548
549 VkImageCreateInfo create_info_;
550 VkFlags format_features_;
551
552 DeviceMemory internal_mem_;
553 };
554
555 class ImageView : public internal::NonDispHandle<VkImageView> {
556 public:
557 ~ImageView() NOEXCEPT;
558
559 // vkCreateImageView()
560 void init(const Device &dev, const VkImageViewCreateInfo &info);
561 };
562
563 class AccelerationStructure : public internal::NonDispHandle<VkAccelerationStructureNV> {
564 public:
565 explicit AccelerationStructure(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true) {
566 init(dev, info, init_memory);
567 }
568 ~AccelerationStructure();
569
570 // vkCreateAccelerationStructureNV
571 void init(const Device &dev, const VkAccelerationStructureCreateInfoNV &info, bool init_memory = true);
572 // vkGetAccelerationStructureMemoryRequirementsNV()
573 VkMemoryRequirements2 memory_requirements() const;
574 VkMemoryRequirements2 build_scratch_memory_requirements() const;
575
opaque_handle()576 uint64_t opaque_handle() const { return opaque_handle_; }
577
info()578 const VkAccelerationStructureInfoNV &info() const { return info_; }
579
dev()580 const VkDevice &dev() const { return device(); }
581
582 void create_scratch_buffer(const Device &dev, Buffer *buffer, VkBufferCreateInfo *pCreateInfo = NULL);
583
584 private:
585 VkAccelerationStructureInfoNV info_;
586 DeviceMemory memory_;
587 uint64_t opaque_handle_;
588 };
589
590 class AccelerationStructureKHR : public internal::NonDispHandle<VkAccelerationStructureKHR> {
591 public:
592 explicit AccelerationStructureKHR(const Device &dev, const VkAccelerationStructureCreateInfoKHR &info,
593 bool init_memory = true) {
594 init(dev, info, init_memory);
595 }
596 ~AccelerationStructureKHR();
597 // vkCreateAccelerationStructureNV
598 void init(const Device &dev, const VkAccelerationStructureCreateInfoKHR &info, bool init_memory = true);
opaque_handle()599 uint64_t opaque_handle() const { return opaque_handle_; }
600
info()601 const VkAccelerationStructureCreateInfoKHR &info() const { return info_; }
602
dev()603 const VkDevice &dev() const { return device(); }
604
605 void create_scratch_buffer(const Device &dev, Buffer *buffer, VkBufferCreateInfo *pCreateInfo = NULL);
606
607 private:
608 VkAccelerationStructureCreateInfoKHR info_;
609 DeviceMemory memory_;
610 uint64_t opaque_handle_;
611 };
612
613 class ShaderModule : public internal::NonDispHandle<VkShaderModule> {
614 public:
615 ~ShaderModule() NOEXCEPT;
616
617 // vkCreateShaderModule()
618 void init(const Device &dev, const VkShaderModuleCreateInfo &info);
619 VkResult init_try(const Device &dev, const VkShaderModuleCreateInfo &info);
620
621 static VkShaderModuleCreateInfo create_info(size_t code_size, const uint32_t *code, VkFlags flags);
622 };
623
624 class Pipeline : public internal::NonDispHandle<VkPipeline> {
625 public:
626 ~Pipeline() NOEXCEPT;
627
628 // vkCreateGraphicsPipeline()
629 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
630 // vkCreateGraphicsPipelineDerivative()
631 void init(const Device &dev, const VkGraphicsPipelineCreateInfo &info, const VkPipeline basePipeline);
632 // vkCreateComputePipeline()
633 void init(const Device &dev, const VkComputePipelineCreateInfo &info);
634 // vkLoadPipeline()
635 void init(const Device &dev, size_t size, const void *data);
636 // vkLoadPipelineDerivative()
637 void init(const Device &dev, size_t size, const void *data, VkPipeline basePipeline);
638
639 // vkCreateGraphicsPipeline with error return
640 VkResult init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info);
641
642 // vkStorePipeline()
643 size_t store(size_t size, void *data);
644 };
645
646 class PipelineLayout : public internal::NonDispHandle<VkPipelineLayout> {
647 public:
PipelineLayout()648 PipelineLayout() NOEXCEPT : NonDispHandle() {}
649 ~PipelineLayout() NOEXCEPT;
650
651 // Move constructor for Visual Studio 2013
PipelineLayout(PipelineLayout && src)652 PipelineLayout(PipelineLayout &&src) NOEXCEPT : NonDispHandle(std::move(src)){};
653
654 PipelineLayout &operator=(PipelineLayout &&src) NOEXCEPT {
655 this->~PipelineLayout();
656 this->NonDispHandle::operator=(std::move(src));
657 return *this;
658 };
659
660 // vCreatePipelineLayout()
661 void init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts);
662 };
663
664 class Sampler : public internal::NonDispHandle<VkSampler> {
665 public:
666 ~Sampler() NOEXCEPT;
667
668 // vkCreateSampler()
669 void init(const Device &dev, const VkSamplerCreateInfo &info);
670 };
671
672 class DescriptorSetLayout : public internal::NonDispHandle<VkDescriptorSetLayout> {
673 public:
DescriptorSetLayout()674 DescriptorSetLayout() NOEXCEPT : NonDispHandle(){};
675 ~DescriptorSetLayout() NOEXCEPT;
676
677 // Move constructor for Visual Studio 2013
DescriptorSetLayout(DescriptorSetLayout && src)678 DescriptorSetLayout(DescriptorSetLayout &&src) NOEXCEPT : NonDispHandle(std::move(src)){};
679
680 DescriptorSetLayout &operator=(DescriptorSetLayout &&src) NOEXCEPT {
681 this->~DescriptorSetLayout();
682 this->NonDispHandle::operator=(std::move(src));
683 return *this;
684 }
685
686 // vkCreateDescriptorSetLayout()
687 void init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info);
688 };
689
690 class DescriptorPool : public internal::NonDispHandle<VkDescriptorPool> {
691 public:
692 ~DescriptorPool() NOEXCEPT;
693
694 // Descriptor sets allocated from this pool will need access to the original
695 // object
GetObj()696 VkDescriptorPool GetObj() { return pool_; }
697
698 // vkCreateDescriptorPool()
699 void init(const Device &dev, const VkDescriptorPoolCreateInfo &info);
700
701 // vkResetDescriptorPool()
702 void reset();
703
704 // vkFreeDescriptorSet()
setDynamicUsage(bool isDynamic)705 void setDynamicUsage(bool isDynamic) { dynamic_usage_ = isDynamic; }
getDynamicUsage()706 bool getDynamicUsage() { return dynamic_usage_; }
707
708 // vkAllocateDescriptorSets()
709 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
710 std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count);
711 DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout);
712
713 template <typename PoolSizes>
714 static VkDescriptorPoolCreateInfo create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
715 const PoolSizes &pool_sizes);
716
717 private:
718 VkDescriptorPool pool_;
719
720 // Track whether this pool's usage is VK_DESCRIPTOR_POOL_USAGE_DYNAMIC
721 bool dynamic_usage_;
722 };
723
724 template <typename PoolSizes>
create_info(VkDescriptorPoolCreateFlags flags,uint32_t max_sets,const PoolSizes & pool_sizes)725 inline VkDescriptorPoolCreateInfo DescriptorPool::create_info(VkDescriptorPoolCreateFlags flags, uint32_t max_sets,
726 const PoolSizes &pool_sizes) {
727 VkDescriptorPoolCreateInfo info{};
728 info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
729 info.pNext = nullptr;
730 info.flags = flags;
731 info.maxSets = max_sets;
732 info.poolSizeCount = pool_sizes.size();
733 info.pPoolSizes = (info.poolSizeCount) ? pool_sizes.data() : nullptr;
734 return info;
735 }
736
737 class DescriptorSet : public internal::NonDispHandle<VkDescriptorSet> {
738 public:
739 ~DescriptorSet() NOEXCEPT;
740
DescriptorSet()741 explicit DescriptorSet() : NonDispHandle() {}
DescriptorSet(const Device & dev,DescriptorPool * pool,VkDescriptorSet set)742 explicit DescriptorSet(const Device &dev, DescriptorPool *pool, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) {
743 containing_pool_ = pool;
744 }
745
746 private:
747 DescriptorPool *containing_pool_;
748 };
749
750 class CommandPool : public internal::NonDispHandle<VkCommandPool> {
751 public:
752 ~CommandPool() NOEXCEPT;
753
CommandPool()754 explicit CommandPool() : NonDispHandle() {}
CommandPool(const Device & dev,const VkCommandPoolCreateInfo & info)755 explicit CommandPool(const Device &dev, const VkCommandPoolCreateInfo &info) { init(dev, info); }
756
757 void init(const Device &dev, const VkCommandPoolCreateInfo &info);
758
759 static VkCommandPoolCreateInfo create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags);
760 };
761
create_info(uint32_t queue_family_index,VkCommandPoolCreateFlags flags)762 inline VkCommandPoolCreateInfo CommandPool::create_info(uint32_t queue_family_index, VkCommandPoolCreateFlags flags) {
763 VkCommandPoolCreateInfo info = {};
764 info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
765 info.queueFamilyIndex = queue_family_index;
766 info.flags = flags;
767 return info;
768 }
769
770 class CommandBuffer : public internal::Handle<VkCommandBuffer> {
771 public:
772 ~CommandBuffer() NOEXCEPT;
773
CommandBuffer()774 explicit CommandBuffer() : Handle() {}
CommandBuffer(const Device & dev,const VkCommandBufferAllocateInfo & info)775 explicit CommandBuffer(const Device &dev, const VkCommandBufferAllocateInfo &info) { init(dev, info); }
776
777 // vkAllocateCommandBuffers()
778 void init(const Device &dev, const VkCommandBufferAllocateInfo &info);
779
780 // vkBeginCommandBuffer()
781 void begin(const VkCommandBufferBeginInfo *info);
782 void begin();
783
784 // vkEndCommandBuffer()
785 // vkResetCommandBuffer()
786 void end();
787 void reset(VkCommandBufferResetFlags flags);
reset()788 void reset() { reset(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
789
790 static VkCommandBufferAllocateInfo create_info(VkCommandPool const &pool);
791
792 private:
793 VkDevice dev_handle_;
794 VkCommandPool cmd_pool_;
795 };
796
alloc_info(VkDeviceSize size,uint32_t memory_type_index)797 inline VkMemoryAllocateInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index) {
798 VkMemoryAllocateInfo info = {};
799 info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
800 info.allocationSize = size;
801 info.memoryTypeIndex = memory_type_index;
802 return info;
803 }
804
create_info(VkDeviceSize size,VkFlags usage,const std::vector<uint32_t> * queue_families)805 inline VkBufferCreateInfo Buffer::create_info(VkDeviceSize size, VkFlags usage, const std::vector<uint32_t> *queue_families) {
806 VkBufferCreateInfo info = {};
807 info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
808 info.size = size;
809 info.usage = usage;
810
811 if (queue_families && queue_families->size() > 1) {
812 info.sharingMode = VK_SHARING_MODE_CONCURRENT;
813 info.queueFamilyIndexCount = static_cast<uint32_t>(queue_families->size());
814 info.pQueueFamilyIndices = queue_families->data();
815 }
816
817 return info;
818 }
819
create_info(VkFenceCreateFlags flags)820 inline VkFenceCreateInfo Fence::create_info(VkFenceCreateFlags flags) {
821 VkFenceCreateInfo info = {};
822 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
823 info.flags = flags;
824 return info;
825 }
826
create_info()827 inline VkFenceCreateInfo Fence::create_info() {
828 VkFenceCreateInfo info = {};
829 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
830 return info;
831 }
832
create_info(VkFlags flags)833 inline VkSemaphoreCreateInfo Semaphore::create_info(VkFlags flags) {
834 VkSemaphoreCreateInfo info = {};
835 info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
836 info.flags = flags;
837 return info;
838 }
839
create_info(VkFlags flags)840 inline VkEventCreateInfo Event::create_info(VkFlags flags) {
841 VkEventCreateInfo info = {};
842 info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
843 info.flags = flags;
844 return info;
845 }
846
create_info(VkQueryType type,uint32_t slot_count)847 inline VkQueryPoolCreateInfo QueryPool::create_info(VkQueryType type, uint32_t slot_count) {
848 VkQueryPoolCreateInfo info = {};
849 info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
850 info.queryType = type;
851 info.queryCount = slot_count;
852 return info;
853 }
854
create_info()855 inline VkImageCreateInfo Image::create_info() {
856 VkImageCreateInfo info = {};
857 info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
858 info.extent.width = 1;
859 info.extent.height = 1;
860 info.extent.depth = 1;
861 info.mipLevels = 1;
862 info.arrayLayers = 1;
863 info.samples = VK_SAMPLE_COUNT_1_BIT;
864 return info;
865 }
866
subresource(VkImageAspectFlags aspect,uint32_t mip_level,uint32_t array_layer)867 inline VkImageSubresource Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer) {
868 VkImageSubresource subres = {};
869 if (aspect == 0) {
870 assert(!"Invalid VkImageAspectFlags");
871 }
872 subres.aspectMask = aspect;
873 subres.mipLevel = mip_level;
874 subres.arrayLayer = array_layer;
875 return subres;
876 }
877
subresource(const VkImageSubresourceRange & range,uint32_t mip_level,uint32_t array_layer)878 inline VkImageSubresource Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer) {
879 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer);
880 }
881
subresource(VkImageAspectFlags aspect,uint32_t mip_level,uint32_t array_layer,uint32_t array_size)882 inline VkImageSubresourceLayers Image::subresource(VkImageAspectFlags aspect, uint32_t mip_level, uint32_t array_layer,
883 uint32_t array_size) {
884 VkImageSubresourceLayers subres = {};
885 switch (aspect) {
886 case VK_IMAGE_ASPECT_COLOR_BIT:
887 case VK_IMAGE_ASPECT_DEPTH_BIT:
888 case VK_IMAGE_ASPECT_STENCIL_BIT:
889 case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT:
890 /* valid */
891 break;
892 default:
893 assert(!"Invalid VkImageAspectFlags");
894 }
895 subres.aspectMask = aspect;
896 subres.mipLevel = mip_level;
897 subres.baseArrayLayer = array_layer;
898 subres.layerCount = array_size;
899 return subres;
900 }
901
subresource(const VkImageSubresourceRange & range,uint32_t mip_level,uint32_t array_layer,uint32_t array_size)902 inline VkImageSubresourceLayers Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer,
903 uint32_t array_size) {
904 return subresource(range.aspectMask, range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer, array_size);
905 }
906
subresource_range(VkImageAspectFlags aspect_mask,uint32_t base_mip_level,uint32_t mip_levels,uint32_t base_array_layer,uint32_t num_layers)907 inline VkImageSubresourceRange Image::subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level,
908 uint32_t mip_levels, uint32_t base_array_layer, uint32_t num_layers) {
909 VkImageSubresourceRange range = {};
910 if (aspect_mask == 0) {
911 assert(!"Invalid VkImageAspectFlags");
912 }
913 range.aspectMask = aspect_mask;
914 range.baseMipLevel = base_mip_level;
915 range.levelCount = mip_levels;
916 range.baseArrayLayer = base_array_layer;
917 range.layerCount = num_layers;
918 return range;
919 }
920
subresource_range(const VkImageCreateInfo & info,VkImageAspectFlags aspect_mask)921 inline VkImageSubresourceRange Image::subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask) {
922 return subresource_range(aspect_mask, 0, info.mipLevels, 0, info.arrayLayers);
923 }
924
subresource_range(const VkImageSubresource & subres)925 inline VkImageSubresourceRange Image::subresource_range(const VkImageSubresource &subres) {
926 return subresource_range(subres.aspectMask, subres.mipLevel, 1, subres.arrayLayer, 1);
927 }
928
extent(int32_t width,int32_t height)929 inline VkExtent2D Image::extent(int32_t width, int32_t height) {
930 VkExtent2D extent = {};
931 extent.width = width;
932 extent.height = height;
933 return extent;
934 }
935
extent(const VkExtent2D & extent,uint32_t mip_level)936 inline VkExtent2D Image::extent(const VkExtent2D &extent, uint32_t mip_level) {
937 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
938 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
939 return Image::extent(width, height);
940 }
941
extent(const VkExtent3D & extent)942 inline VkExtent2D Image::extent(const VkExtent3D &extent) { return Image::extent(extent.width, extent.height); }
943
extent(int32_t width,int32_t height,int32_t depth)944 inline VkExtent3D Image::extent(int32_t width, int32_t height, int32_t depth) {
945 VkExtent3D extent = {};
946 extent.width = width;
947 extent.height = height;
948 extent.depth = depth;
949 return extent;
950 }
951
extent(const VkExtent3D & extent,uint32_t mip_level)952 inline VkExtent3D Image::extent(const VkExtent3D &extent, uint32_t mip_level) {
953 const int32_t width = (extent.width >> mip_level) ? extent.width >> mip_level : 1;
954 const int32_t height = (extent.height >> mip_level) ? extent.height >> mip_level : 1;
955 const int32_t depth = (extent.depth >> mip_level) ? extent.depth >> mip_level : 1;
956 return Image::extent(width, height, depth);
957 }
958
create_info(size_t code_size,const uint32_t * code,VkFlags flags)959 inline VkShaderModuleCreateInfo ShaderModule::create_info(size_t code_size, const uint32_t *code, VkFlags flags) {
960 VkShaderModuleCreateInfo info = {};
961 info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
962 info.codeSize = code_size;
963 info.pCode = code;
964 info.flags = flags;
965 return info;
966 }
967
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkDescriptorImageInfo * image_info)968 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
969 VkDescriptorType type, uint32_t count,
970 const VkDescriptorImageInfo *image_info) {
971 VkWriteDescriptorSet write = {};
972 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
973 write.dstSet = set.handle();
974 write.dstBinding = binding;
975 write.dstArrayElement = array_element;
976 write.descriptorCount = count;
977 write.descriptorType = type;
978 write.pImageInfo = image_info;
979 return write;
980 }
981
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkDescriptorBufferInfo * buffer_info)982 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
983 VkDescriptorType type, uint32_t count,
984 const VkDescriptorBufferInfo *buffer_info) {
985 VkWriteDescriptorSet write = {};
986 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
987 write.dstSet = set.handle();
988 write.dstBinding = binding;
989 write.dstArrayElement = array_element;
990 write.descriptorCount = count;
991 write.descriptorType = type;
992 write.pBufferInfo = buffer_info;
993 return write;
994 }
995
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,uint32_t count,const VkBufferView * buffer_views)996 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
997 VkDescriptorType type, uint32_t count, const VkBufferView *buffer_views) {
998 VkWriteDescriptorSet write = {};
999 write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
1000 write.dstSet = set.handle();
1001 write.dstBinding = binding;
1002 write.dstArrayElement = array_element;
1003 write.descriptorCount = count;
1004 write.descriptorType = type;
1005 write.pTexelBufferView = buffer_views;
1006 return write;
1007 }
1008
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkDescriptorImageInfo> & image_info)1009 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
1010 VkDescriptorType type,
1011 const std::vector<VkDescriptorImageInfo> &image_info) {
1012 return write_descriptor_set(set, binding, array_element, type, image_info.size(), &image_info[0]);
1013 }
1014
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkDescriptorBufferInfo> & buffer_info)1015 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
1016 VkDescriptorType type,
1017 const std::vector<VkDescriptorBufferInfo> &buffer_info) {
1018 return write_descriptor_set(set, binding, array_element, type, buffer_info.size(), &buffer_info[0]);
1019 }
1020
write_descriptor_set(const DescriptorSet & set,uint32_t binding,uint32_t array_element,VkDescriptorType type,const std::vector<VkBufferView> & buffer_views)1021 inline VkWriteDescriptorSet Device::write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
1022 VkDescriptorType type, const std::vector<VkBufferView> &buffer_views) {
1023 return write_descriptor_set(set, binding, array_element, type, buffer_views.size(), &buffer_views[0]);
1024 }
1025
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)1026 inline VkCopyDescriptorSet Device::copy_descriptor_set(const DescriptorSet &src_set, uint32_t src_binding,
1027 uint32_t src_array_element, const DescriptorSet &dst_set,
1028 uint32_t dst_binding, uint32_t dst_array_element, uint32_t count) {
1029 VkCopyDescriptorSet copy = {};
1030 copy.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
1031 copy.srcSet = src_set.handle();
1032 copy.srcBinding = src_binding;
1033 copy.srcArrayElement = src_array_element;
1034 copy.dstSet = dst_set.handle();
1035 copy.dstBinding = dst_binding;
1036 copy.dstArrayElement = dst_array_element;
1037 copy.descriptorCount = count;
1038
1039 return copy;
1040 }
1041
create_info(VkCommandPool const & pool)1042 inline VkCommandBufferAllocateInfo CommandBuffer::create_info(VkCommandPool const &pool) {
1043 VkCommandBufferAllocateInfo info = {};
1044 info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
1045 info.commandPool = pool;
1046 info.commandBufferCount = 1;
1047 return info;
1048 }
1049
1050 } // namespace vk_testing
1051
1052 #endif // VKTESTBINDING_H
1053