xref: /aosp_15_r20/external/OpenCL-CTS/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp (revision 6467f958c7de8070b317fc65bcb0f6472e388d82) 
1 //
2 // Copyright (c) 2022 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //    http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #ifndef _vulkan_wrapper_hpp_
18 #define _vulkan_wrapper_hpp_
19 
20 #include <vulkan/vulkan.h>
21 #include "vulkan_wrapper_types.hpp"
22 #include "vulkan_list_map.hpp"
23 #include "vulkan_api_list.hpp"
24 #include <memory>
25 
26 class VulkanInstance {
27     friend const VulkanInstance &getVulkanInstance();
28 
29 protected:
30     VkInstance m_vkInstance;
31     VulkanPhysicalDeviceList m_physicalDeviceList;
32 
33     VulkanInstance();
34     VulkanInstance(const VulkanInstance &);
35     virtual ~VulkanInstance();
36 
37 public:
38     const VulkanPhysicalDeviceList &getPhysicalDeviceList() const;
39     operator VkInstance() const;
40 };
41 
42 class VulkanPhysicalDevice {
43     friend class VulkanInstance;
44 
45 protected:
46     VkPhysicalDevice m_vkPhysicalDevice;
47     VkPhysicalDeviceProperties m_vkPhysicalDeviceProperties;
48     uint8_t m_vkDeviceUUID[VK_UUID_SIZE];
49     uint8_t m_vkDeviceLUID[VK_LUID_SIZE];
50     uint32_t m_vkDeviceNodeMask;
51     VkPhysicalDeviceFeatures m_vkPhysicalDeviceFeatures;
52     VkPhysicalDeviceMemoryProperties m_vkPhysicalDeviceMemoryProperties;
53     VulkanQueueFamilyList m_queueFamilyList;
54     VulkanMemoryHeapList m_memoryHeapList;
55     VulkanMemoryTypeList m_memoryTypeList;
56 
57     VulkanPhysicalDevice(const VulkanPhysicalDevice &physicalDevice);
58     VulkanPhysicalDevice(VkPhysicalDevice vkPhysicalDevice);
59     virtual ~VulkanPhysicalDevice();
60 
61 public:
62     const VulkanQueueFamilyList &getQueueFamilyList() const;
63     const VulkanMemoryHeapList &getMemoryHeapList() const;
64     const VulkanMemoryTypeList &getMemoryTypeList() const;
65     const uint8_t *getUUID() const;
66     const uint8_t *getLUID() const;
67     uint32_t getNodeMask() const;
68     operator VkPhysicalDevice() const;
69 };
70 
71 class VulkanMemoryHeap {
72     friend class VulkanPhysicalDevice;
73 
74 protected:
75     uint32_t m_memoryHeapIndex;
76     uint64_t m_size;
77     VulkanMemoryHeapFlag m_memoryHeapFlag;
78 
79     VulkanMemoryHeap(const VulkanMemoryHeap &memoryHeap);
80     VulkanMemoryHeap(uint32_t m_memoryHeapIndex, uint64_t m_size,
81                      VulkanMemoryHeapFlag m_memoryHeapFlag);
82     virtual ~VulkanMemoryHeap();
83 
84 public:
85     uint64_t getSize() const;
86     VulkanMemoryHeapFlag getMemoryHeapFlag() const;
87     operator uint32_t() const;
88 };
89 
90 class VulkanMemoryType {
91     friend class VulkanPhysicalDevice;
92 
93 protected:
94     uint32_t m_memoryTypeIndex;
95     const VulkanMemoryTypeProperty m_memoryTypeProperty;
96     const VulkanMemoryHeap &m_memoryHeap;
97 
98     VulkanMemoryType(const VulkanMemoryType &memoryType);
99     VulkanMemoryType(uint32_t memoryTypeIndex,
100                      VulkanMemoryTypeProperty memoryTypeProperty,
101                      const VulkanMemoryHeap &memoryHeap);
102     virtual ~VulkanMemoryType();
103 
104 public:
105     VulkanMemoryTypeProperty getMemoryTypeProperty() const;
106     const VulkanMemoryHeap &getMemoryHeap() const;
107     operator uint32_t() const;
108 };
109 
110 class VulkanQueueFamily {
111     friend class VulkanPhysicalDevice;
112 
113 protected:
114     uint32_t m_queueFamilyIndex;
115     VkQueueFamilyProperties m_vkQueueFamilyProperties;
116 
117     VulkanQueueFamily(const VulkanQueueFamily &queueFamily);
118     VulkanQueueFamily(uint32_t queueFamilyIndex,
119                       VkQueueFamilyProperties vkQueueFamilyProperties);
120     virtual ~VulkanQueueFamily();
121 
122 public:
123     uint32_t getQueueFlags() const;
124     uint32_t getQueueCount() const;
125     operator uint32_t() const;
126 };
127 
128 class VulkanDevice {
129 protected:
130     const VulkanPhysicalDevice &m_physicalDevice;
131     VkDevice m_vkDevice;
132     VulkanQueueFamilyToQueueListMap m_queueFamilyIndexToQueueListMap;
133 
134     VulkanDevice(const VulkanDevice &device);
135 
136 public:
137     VulkanDevice(
138         const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice(),
139         const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap =
140             getDefaultVulkanQueueFamilyToQueueCountMap());
141     virtual ~VulkanDevice();
142     const VulkanPhysicalDevice &getPhysicalDevice() const;
143     VulkanQueue &
144     getQueue(const VulkanQueueFamily &queueFamily = getVulkanQueueFamily(),
145              uint32_t queueIndex = 0);
146     operator VkDevice() const;
147 };
148 
149 class VulkanFence {
150     friend class VulkanQueue;
151 
152 protected:
153     VkFence fence;
154     VkDevice device;
155 
156 public:
157     VulkanFence(const VulkanDevice &device);
158     virtual ~VulkanFence();
159     void reset();
160     void wait();
161 };
162 
163 class VulkanQueue {
164     friend class VulkanDevice;
165 
166 protected:
167     VkQueue m_vkQueue;
168 
169     VulkanQueue(VkQueue vkQueue);
170     VulkanQueue(const VulkanQueue &queue);
171     virtual ~VulkanQueue();
172 
173 public:
174     const VulkanQueueFamily &getQueueFamily();
175     void submit(const VulkanCommandBuffer &commandBuffer,
176                 const std::shared_ptr<VulkanFence> &fence);
177     void submit(const VulkanSemaphoreList &waitSemaphoreList,
178                 const VulkanCommandBufferList &commandBufferList,
179                 const VulkanSemaphoreList &signalSemaphoreList);
180     void submit(const VulkanSemaphore &waitSemaphore,
181                 const VulkanCommandBuffer &commandBuffer,
182                 const VulkanSemaphore &signalSemaphore);
183     void submit(const VulkanCommandBuffer &commandBuffer,
184                 const VulkanSemaphore &signalSemaphore);
185     void submit(const VulkanCommandBuffer &commandBuffer);
186     void waitIdle();
187     operator VkQueue() const;
188 };
189 
190 class VulkanDescriptorSetLayoutBinding {
191 protected:
192     VkDescriptorSetLayoutBinding m_vkDescriptorSetLayoutBinding;
193 
194     VulkanDescriptorSetLayoutBinding(
195         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
196 
197 public:
198     VulkanDescriptorSetLayoutBinding(
199         uint32_t binding, VulkanDescriptorType descriptorType,
200         uint32_t descriptorCount = 1,
201         VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
202     virtual ~VulkanDescriptorSetLayoutBinding();
203     operator VkDescriptorSetLayoutBinding() const;
204 };
205 
206 class VulkanDescriptorSetLayout {
207 protected:
208     const VulkanDevice &m_device;
209     VkDescriptorSetLayout m_vkDescriptorSetLayout;
210 
211     VulkanDescriptorSetLayout(
212         const VulkanDescriptorSetLayout &descriptorSetLayout);
213     void
214     VulkanDescriptorSetLayoutCommon(const VulkanDescriptorSetLayoutBindingList
215                                         &descriptorSetLayoutBindingList);
216 
217 public:
218     VulkanDescriptorSetLayout(
219         const VulkanDevice &device,
220         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
221     VulkanDescriptorSetLayout(
222         const VulkanDevice &device,
223         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
224         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
225     VulkanDescriptorSetLayout(const VulkanDevice &device,
226                               const VulkanDescriptorSetLayoutBindingList
227                                   &descriptorSetLayoutBindingList);
228     virtual ~VulkanDescriptorSetLayout();
229     operator VkDescriptorSetLayout() const;
230 };
231 
232 class VulkanPipelineLayout {
233 protected:
234     const VulkanDevice &m_device;
235     VkPipelineLayout m_vkPipelineLayout;
236 
237     VulkanPipelineLayout(const VulkanPipelineLayout &pipelineLayout);
238     void VulkanPipelineLayoutCommon(
239         const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
240 
241 public:
242     VulkanPipelineLayout(const VulkanDevice &device,
243                          const VulkanDescriptorSetLayout &descriptorSetLayout);
244     VulkanPipelineLayout(
245         const VulkanDevice &device,
246         const VulkanDescriptorSetLayoutList &descriptorSetLayoutList =
247             getEmptyVulkanDescriptorSetLayoutList());
248     virtual ~VulkanPipelineLayout();
249     operator VkPipelineLayout() const;
250 };
251 
252 class VulkanShaderModule {
253 protected:
254     const VulkanDevice &m_device;
255     VkShaderModule m_vkShaderModule;
256 
257     VulkanShaderModule(const VulkanShaderModule &shaderModule);
258 
259 public:
260     VulkanShaderModule(const VulkanDevice &device,
261                        const std::vector<char> &code);
262     virtual ~VulkanShaderModule();
263     operator VkShaderModule() const;
264 };
265 
266 class VulkanPipeline {
267 protected:
268     const VulkanDevice &m_device;
269     VkPipeline m_vkPipeline;
270 
271     VulkanPipeline(const VulkanPipeline &pipeline);
272 
273 public:
274     VulkanPipeline(const VulkanDevice &device);
275     virtual ~VulkanPipeline();
276     virtual VulkanPipelineBindPoint getPipelineBindPoint() const = 0;
277     operator VkPipeline() const;
278 };
279 
280 class VulkanComputePipeline : public VulkanPipeline {
281 protected:
282     VulkanComputePipeline(const VulkanComputePipeline &computePipeline);
283 
284 public:
285     VulkanComputePipeline(const VulkanDevice &device,
286                           const VulkanPipelineLayout &pipelineLayout,
287                           const VulkanShaderModule &shaderModule,
288                           const std::string &entryFuncName = "main");
289     virtual ~VulkanComputePipeline();
290     VulkanPipelineBindPoint getPipelineBindPoint() const;
291 };
292 
293 class VulkanDescriptorPool {
294 protected:
295     const VulkanDevice &m_device;
296     VkDescriptorPool m_vkDescriptorPool;
297 
298     VulkanDescriptorPool(const VulkanDescriptorPool &descriptorPool);
299     void VulkanDescriptorPoolCommon(const VulkanDescriptorSetLayoutBindingList
300                                         &descriptorSetLayoutBindingList);
301 
302 public:
303     VulkanDescriptorPool(
304         const VulkanDevice &device,
305         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
306     VulkanDescriptorPool(
307         const VulkanDevice &device,
308         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
309         const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
310     VulkanDescriptorPool(const VulkanDevice &device,
311                          const VulkanDescriptorSetLayoutBindingList
312                              &descriptorSetLayoutBindingList);
313     virtual ~VulkanDescriptorPool();
314     operator VkDescriptorPool() const;
315 };
316 
317 class VulkanDescriptorSet {
318 protected:
319     const VulkanDevice &m_device;
320     const VulkanDescriptorPool &m_descriptorPool;
321     VkDescriptorSet m_vkDescriptorSet;
322 
323     VulkanDescriptorSet(const VulkanDescriptorSet &descriptorSet);
324 
325 public:
326     VulkanDescriptorSet(const VulkanDevice &device,
327                         const VulkanDescriptorPool &descriptorPool,
328                         const VulkanDescriptorSetLayout &descriptorSetLayout);
329     virtual ~VulkanDescriptorSet();
330     void update(uint32_t binding, const VulkanBuffer &buffer);
331     void updateArray(uint32_t binding, unsigned numBuffers,
332                      const VulkanBufferList &buffers);
333     void update(uint32_t binding, const VulkanImageView &imageView);
334     void updateArray(uint32_t binding,
335                      const VulkanImageViewList &imageViewList);
336     operator VkDescriptorSet() const;
337 };
338 
339 class VulkanOffset3D {
340 protected:
341     VkOffset3D m_vkOffset3D;
342 
343 public:
344     VulkanOffset3D(const VulkanOffset3D &extent3D);
345     VulkanOffset3D(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
346     virtual ~VulkanOffset3D();
347     uint32_t getX() const;
348     uint32_t getY() const;
349     uint32_t getZ() const;
350     operator VkOffset3D() const;
351 };
352 
353 class VulkanExtent3D {
354 protected:
355     VkExtent3D m_vkExtent3D;
356 
357 public:
358     VulkanExtent3D(const VulkanExtent3D &extent3D);
359     VulkanExtent3D(uint32_t width, uint32_t height = 1, uint32_t depth = 1);
360     virtual ~VulkanExtent3D();
361     uint32_t getWidth() const;
362     uint32_t getHeight() const;
363     uint32_t getDepth() const;
364     operator VkExtent3D() const;
365 };
366 
367 class VulkanCommandPool {
368 protected:
369     const VulkanDevice &m_device;
370     VkCommandPool m_vkCommandPool;
371 
372     VulkanCommandPool(const VulkanCommandPool &commandPool);
373 
374 public:
375     VulkanCommandPool(
376         const VulkanDevice &device,
377         const VulkanQueueFamily &queueFamily = getVulkanQueueFamily());
378     virtual ~VulkanCommandPool();
379     operator VkCommandPool() const;
380 };
381 
382 class VulkanCommandBuffer {
383 protected:
384     const VulkanDevice &m_device;
385     const VulkanCommandPool &m_commandPool;
386     VkCommandBuffer m_vkCommandBuffer;
387 
388     VulkanCommandBuffer(const VulkanCommandBuffer &commandBuffer);
389 
390 public:
391     VulkanCommandBuffer(const VulkanDevice &device,
392                         const VulkanCommandPool &commandPool);
393     virtual ~VulkanCommandBuffer();
394     void begin();
395     void bindPipeline(const VulkanPipeline &pipeline);
396     void bindDescriptorSets(const VulkanPipeline &pipeline,
397                             const VulkanPipelineLayout &pipelineLayout,
398                             const VulkanDescriptorSet &descriptorSet);
399     void pipelineBarrier(const VulkanImage2DList &image2DList,
400                          VulkanImageLayout oldImageLayout,
401                          VulkanImageLayout newImageLayout);
402     void dispatch(uint32_t groupCountX, uint32_t groupCountY,
403                   uint32_t groupCountZ);
404     void fillBuffer(const VulkanBuffer &buffer, uint32_t data,
405                     uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
406     void updateBuffer(const VulkanBuffer &buffer, void *pdata,
407                       uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
408     void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
409                            VulkanImageLayout imageLayout =
410                                VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
411     void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
412                            uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
413                            uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
414                            VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
415                            VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
416     void copyImageToBuffer(const VulkanImage &image, const VulkanBuffer &buffer,
417                            uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
418                            uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
419                            VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
420                            VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
421     void end();
422     operator VkCommandBuffer() const;
423 };
424 
425 class VulkanBuffer {
426 protected:
427     const VulkanDevice &m_device;
428     VkBuffer m_vkBuffer;
429     uint64_t m_size;
430     uint64_t m_alignment;
431     bool m_dedicated;
432     VulkanMemoryTypeList m_memoryTypeList;
433 
434     VulkanBuffer(const VulkanBuffer &buffer);
435 
436 public:
437     VulkanBuffer(const VulkanDevice &device, uint64_t size,
438                  VulkanExternalMemoryHandleType externalMemoryHandleType =
439                      VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
440                  VulkanBufferUsage bufferUsage =
441                      VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
442                  VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
443                  const VulkanQueueFamilyList &queueFamilyList =
444                      getEmptyVulkanQueueFamilyList());
445     virtual ~VulkanBuffer();
446     uint64_t getSize() const;
447     uint64_t getAlignment() const;
448     const VulkanMemoryTypeList &getMemoryTypeList() const;
449     bool isDedicated() const;
450     operator VkBuffer() const;
451 };
452 
453 class VulkanImage {
454 protected:
455     const VulkanDevice &m_device;
456     const VulkanImageType m_imageType;
457     const VulkanExtent3D m_extent3D;
458     const VulkanFormat m_format;
459     const uint32_t m_numMipLevels;
460     const uint32_t m_numLayers;
461     bool m_dedicated;
462     VkImage m_vkImage;
463     uint64_t m_size;
464     uint64_t m_alignment;
465     VulkanMemoryTypeList m_memoryTypeList;
466     VkImageCreateInfo VulkanImageCreateInfo;
467     VulkanImage(const VulkanImage &image);
468 
469 public:
470     VulkanImage(
471         const VulkanDevice &device, VulkanImageType imageType,
472         VulkanFormat format, const VulkanExtent3D &extent3D,
473         uint32_t numMipLevels = 1, uint32_t arrayLayers = 1,
474         VulkanExternalMemoryHandleType externalMemoryHandleType =
475             VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
476         VulkanImageCreateFlag imageCreateFlags = VULKAN_IMAGE_CREATE_FLAG_NONE,
477         VulkanImageTiling imageTiling = VULKAN_IMAGE_TILING_OPTIMAL,
478         VulkanImageUsage imageUsage =
479             VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
480         VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
481     virtual ~VulkanImage();
482     virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
483     VulkanFormat getFormat() const;
484     uint32_t getNumMipLevels() const;
485     uint32_t getNumLayers() const;
486     uint64_t getSize() const;
487     uint64_t getAlignment() const;
488     bool isDedicated() const;
489     const VulkanMemoryTypeList &getMemoryTypeList() const;
490     VkImageCreateInfo getVkImageCreateInfo() const;
491     operator VkImage() const;
492 };
493 
494 class VulkanImage2D : public VulkanImage {
495 protected:
496     VkImageView m_vkImageView;
497 
498 public:
499     VulkanImage2D(
500         const VulkanDevice &device, VulkanFormat format, uint32_t width,
501         uint32_t height, VulkanImageTiling imageTiling,
502         uint32_t numMipLevels = 1,
503         VulkanExternalMemoryHandleType externalMemoryHandleType =
504             VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
505         VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
506         VulkanImageUsage imageUsage =
507             VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
508         VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
509     virtual ~VulkanImage2D();
510     virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
511 
512     VulkanImage2D(const VulkanImage2D &image2D);
513 };
514 
515 class VulkanImageView {
516 protected:
517     const VulkanDevice &m_device;
518     VkImageView m_vkImageView;
519 
520     VulkanImageView(const VulkanImageView &imageView);
521 
522 public:
523     VulkanImageView(const VulkanDevice &device, const VulkanImage &image,
524                     VulkanImageViewType imageViewType,
525                     uint32_t baseMipLevel = 0,
526                     uint32_t mipLevelCount = VULKAN_REMAINING_MIP_LEVELS,
527                     uint32_t baseArrayLayer = 0,
528                     uint32_t layerCount = VULKAN_REMAINING_ARRAY_LAYERS);
529     virtual ~VulkanImageView();
530     operator VkImageView() const;
531 };
532 
533 class VulkanDeviceMemory {
534 protected:
535     const VulkanDevice &m_device;
536     VkDeviceMemory m_vkDeviceMemory;
537     uint64_t m_size;
538     bool m_isDedicated;
539 
540     VulkanDeviceMemory(const VulkanDeviceMemory &deviceMemory);
541 
542 public:
543     VulkanDeviceMemory(const VulkanDevice &device, uint64_t size,
544                        const VulkanMemoryType &memoryType,
545                        VulkanExternalMemoryHandleType externalMemoryHandleType =
546                            VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
547                        const void *name = NULL);
548     VulkanDeviceMemory(const VulkanDevice &device, const VulkanImage &image,
549                        const VulkanMemoryType &memoryType,
550                        VulkanExternalMemoryHandleType externalMemoryHandleType =
551                            VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
552                        const void *name = NULL);
553     VulkanDeviceMemory(const VulkanDevice &device, const VulkanBuffer &buffer,
554                        const VulkanMemoryType &memoryType,
555                        VulkanExternalMemoryHandleType externalMemoryHandleType =
556                            VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
557                        const void *name = NULL);
558     virtual ~VulkanDeviceMemory();
559     uint64_t getSize() const;
560 #ifdef _WIN32
561     HANDLE
562     getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
563 #else
564     int
565     getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
566 #endif
567     bool isDedicated() const;
568     void *map(size_t offset = 0, size_t size = VK_WHOLE_SIZE);
569     void unmap();
570     void bindBuffer(const VulkanBuffer &buffer, uint64_t offset = 0);
571     void bindImage(const VulkanImage &image, uint64_t offset = 0);
572     operator VkDeviceMemory() const;
573 };
574 
575 class VulkanSemaphore {
576     friend class VulkanQueue;
577 
578 protected:
579     const VulkanDevice &m_device;
580     VkSemaphore m_vkSemaphore;
581     const std::wstring m_name;
582 
583     VulkanSemaphore(const VulkanSemaphore &semaphore);
584 
585 public:
586     VulkanSemaphore(
587         const VulkanDevice &device,
588         VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
589             VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
590         const std::wstring name = L"");
591     virtual ~VulkanSemaphore();
592 #ifdef _WIN32
593     HANDLE getHandle(
594         VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
595 #else
596     int getHandle(
597         VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
598 #endif
599     const std::wstring &getName() const;
600     operator VkSemaphore() const;
601 };
602 
603 #define VK_FUNC_DECL(name) extern "C" PFN_##name _##name;
604 VK_FUNC_LIST
605 #if defined(_WIN32) || defined(_WIN64)
606 VK_WINDOWS_FUNC_LIST
607 #endif
608 #undef VK_FUNC_DECL
609 
610 #endif // _vulkan_wrapper_hpp_
611