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_list_map_hpp_
18 #define _vulkan_list_map_hpp_
19
20 #include <functional>
21 #include "vulkan_wrapper_types.hpp"
22 #include "vulkan_utility.hpp"
23 #include <iostream>
24 template <class VulkanWrapper, class VulkanNative> class VulkanList {
25 protected:
26 std::vector<std::reference_wrapper<VulkanWrapper>> m_wrapperList;
27 std::vector<std::reference_wrapper<const VulkanWrapper>> m_constWrapperList;
28 std::vector<VulkanNative> m_nativeList;
29
30 VulkanList(const VulkanList &list);
31 VulkanList();
32 virtual ~VulkanList();
33 virtual void add(VulkanWrapper &wrapper);
34
35 public:
36 virtual void add(const VulkanWrapper &wrapper);
37 virtual size_t size() const;
38 virtual const VulkanWrapper &operator[](size_t idx) const;
39 virtual VulkanWrapper &operator[](size_t idx);
40 virtual const VulkanNative *operator()() const;
41 };
42
43 template <class VulkanKey, class VulkanValue> class VulkanMap {
44 protected:
45 std::map<VulkanKey, VulkanValue> m_map;
46
47 VulkanMap(const VulkanMap &map);
48 VulkanMap();
49 virtual ~VulkanMap();
50
51 public:
52 void insert(const VulkanKey &key, VulkanValue &value);
53 const VulkanValue &operator[](const VulkanKey &key) const;
54 VulkanValue &operator[](const VulkanKey &key);
55 };
56
57 class VulkanPhysicalDeviceList
58 : public VulkanList<VulkanPhysicalDevice, VkPhysicalDevice> {
59 friend class VulkanInstance;
60
61 protected:
62 VulkanPhysicalDeviceList(
63 const VulkanPhysicalDeviceList &physicalDeviceList);
64
65 public:
66 VulkanPhysicalDeviceList();
67 virtual ~VulkanPhysicalDeviceList();
68 };
69
70 class VulkanQueueFamilyList : public VulkanList<VulkanQueueFamily, uint32_t> {
71 friend class VulkanPhysicalDevice;
72
73 protected:
74 VulkanQueueFamilyList(const VulkanQueueFamilyList &queueFamilyList);
75
76 public:
77 VulkanQueueFamilyList();
78 virtual ~VulkanQueueFamilyList();
79 };
80
81 class VulkanMemoryHeapList : public VulkanList<VulkanMemoryHeap, uint32_t> {
82 friend class VulkanPhysicalDevice;
83
84 protected:
85 VulkanMemoryHeapList(const VulkanMemoryHeapList &memoryHeapList);
86
87 public:
88 VulkanMemoryHeapList();
89 virtual ~VulkanMemoryHeapList();
90 };
91
92 class VulkanMemoryTypeList : public VulkanList<VulkanMemoryType, uint32_t> {
93 friend class VulkanPhysicalDevice;
94 friend class VulkanBuffer;
95 friend class VulkanImage;
96
97 protected:
98 VulkanMemoryTypeList(const VulkanMemoryTypeList &memoryTypeList);
99
100 public:
101 VulkanMemoryTypeList();
102 virtual ~VulkanMemoryTypeList();
103 };
104
105 class VulkanQueueFamilyToQueueCountMap : public VulkanMap<uint32_t, uint32_t> {
106 protected:
107 VulkanQueueFamilyToQueueCountMap(
108 const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap);
109
110 public:
111 VulkanQueueFamilyToQueueCountMap(uint32_t numQueuesPerFamily = 0);
112 virtual ~VulkanQueueFamilyToQueueCountMap();
113 };
114
115 class VulkanQueueList : public VulkanList<VulkanQueue, VkQueue> {
116 friend class VulkanDevice;
117
118 protected:
119 VulkanQueueList(const VulkanQueueList &queueList);
120
121 public:
122 VulkanQueueList();
123 virtual ~VulkanQueueList();
124 };
125
126 class VulkanQueueFamilyToQueueListMap
127 : public VulkanMap<uint32_t, std::reference_wrapper<VulkanQueueList>> {
128 protected:
129 VulkanQueueFamilyToQueueListMap(
130 const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap);
131
132 public:
133 VulkanQueueFamilyToQueueListMap();
134 virtual ~VulkanQueueFamilyToQueueListMap();
135 void insert(uint32_t key, VulkanQueueList &queueList);
136 VulkanQueueList &operator[](uint32_t key);
137 };
138
139 class VulkanDescriptorSetLayoutBindingList
140 : public VulkanList<VulkanDescriptorSetLayoutBinding,
141 VkDescriptorSetLayoutBinding> {
142 protected:
143 VulkanDescriptorSetLayoutBindingList(
144 const VulkanDescriptorSetLayoutBindingList
145 &descriptorSetLayoutBindingList);
146
147 public:
148 VulkanDescriptorSetLayoutBindingList();
149 VulkanDescriptorSetLayoutBindingList(
150 size_t numDescriptorSetLayoutBindings,
151 VulkanDescriptorType descriptorType, uint32_t descriptorCount = 1,
152 VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
153 VulkanDescriptorSetLayoutBindingList(
154 VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
155 VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
156 VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
157 virtual ~VulkanDescriptorSetLayoutBindingList();
158 };
159
160 class VulkanDescriptorSetLayoutList
161 : public VulkanList<VulkanDescriptorSetLayout, VkDescriptorSetLayout> {
162 protected:
163 VulkanDescriptorSetLayoutList(
164 const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
165
166 public:
167 VulkanDescriptorSetLayoutList();
168 virtual ~VulkanDescriptorSetLayoutList();
169 };
170
171 class VulkanCommandBufferList
172 : public VulkanList<VulkanCommandBuffer, VkCommandBuffer> {
173 protected:
174 VulkanCommandBufferList(const VulkanCommandBufferList &commandBufferList);
175
176 public:
177 VulkanCommandBufferList();
178 VulkanCommandBufferList(size_t numCommandBuffers,
179 const VulkanDevice &device,
180 const VulkanCommandPool &commandPool);
181 virtual ~VulkanCommandBufferList();
182 };
183
184 class VulkanBufferList : public VulkanList<VulkanBuffer, VkBuffer> {
185 protected:
186 VulkanBufferList(const VulkanBufferList &bufferList);
187
188 public:
189 VulkanBufferList(
190 size_t numBuffers, const VulkanDevice &device, uint64_t size,
191 VulkanExternalMemoryHandleType externalMemoryHandleType =
192 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
193 VulkanBufferUsage bufferUsage =
194 VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
195 VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
196 const VulkanQueueFamilyList &queueFamilyList =
197 getEmptyVulkanQueueFamilyList());
198 virtual ~VulkanBufferList();
199 };
200
201 class VulkanImage2DList : public VulkanList<VulkanImage2D, VkImage> {
202 protected:
203 VulkanImage2DList(const VulkanImage2DList &image2DList);
204
205 public:
206 VulkanImage2DList(
207 size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
208 uint64_t baseOffset, uint64_t interImageOffset,
209 const VulkanDevice &device, VulkanFormat format, uint32_t width,
210 uint32_t height, uint32_t mipLevels,
211 VulkanExternalMemoryHandleType externalMemoryHandleType =
212 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
213 VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
214 VulkanImageUsage imageUsage =
215 VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
216 VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
217 VulkanImage2DList(
218 size_t numImages, const VulkanDevice &device, VulkanFormat format,
219 uint32_t width, uint32_t height, uint32_t mipLevels = 1,
220 VulkanExternalMemoryHandleType externalMemoryHandleType =
221 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
222 VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
223 VulkanImageUsage imageUsage =
224 VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
225 VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
226 virtual ~VulkanImage2DList();
227 };
228
229 class VulkanImageViewList : public VulkanList<VulkanImageView, VkImageView> {
230 protected:
231 VulkanImageViewList(const VulkanImageViewList &imageViewList);
232
233 public:
234 VulkanImageViewList(const VulkanDevice &device,
235 const VulkanImage2DList &image2DList,
236 bool createImageViewPerMipLevel = true);
237 virtual ~VulkanImageViewList();
238 };
239
240 class VulkanDeviceMemoryList
241 : public VulkanList<VulkanDeviceMemory, VkDeviceMemory> {
242 protected:
243 VulkanDeviceMemoryList(const VulkanDeviceMemoryList &deviceMemoryList);
244
245 public:
246 VulkanDeviceMemoryList(
247 size_t numImages, const VulkanImage2DList &image2DList,
248 const VulkanDevice &device, const VulkanMemoryType &memoryType,
249 VulkanExternalMemoryHandleType externalMemoryHandleType =
250 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE);
251 virtual ~VulkanDeviceMemoryList();
252 };
253
254 class VulkanSemaphoreList : public VulkanList<VulkanSemaphore, VkSemaphore> {
255 protected:
256 VulkanSemaphoreList(const VulkanSemaphoreList &semaphoreList);
257
258 public:
259 VulkanSemaphoreList();
260 VulkanSemaphoreList(
261 size_t numSemaphores, const VulkanDevice &device,
262 VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
263 VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
264 const std::wstring namePrefix = L"");
265 virtual ~VulkanSemaphoreList();
266 };
267
268 ///////////////////////////////
269 // VulkanList implementation //
270 ///////////////////////////////
271
272 template <class VulkanWrapper, class VulkanNative>
VulkanList(const VulkanList & list)273 VulkanList<VulkanWrapper, VulkanNative>::VulkanList(const VulkanList &list)
274 : m_wrapperList(list.m_wrapperList),
275 m_constWrapperList(list.m_constWrapperList),
276 m_nativeList(list.m_nativeList)
277 {}
278
279 template <class VulkanWrapper, class VulkanNative>
VulkanList()280 VulkanList<VulkanWrapper, VulkanNative>::VulkanList()
281 {}
282
283 template <class VulkanWrapper, class VulkanNative>
~VulkanList()284 VulkanList<VulkanWrapper, VulkanNative>::~VulkanList()
285 {}
286
287 template <class VulkanWrapper, class VulkanNative>
add(VulkanWrapper & wrapper)288 void VulkanList<VulkanWrapper, VulkanNative>::add(VulkanWrapper &wrapper)
289 {
290
291 if (m_constWrapperList.size() != size_t(0))
292 {
293 std::cout << "This list can only contain externally allocated objects"
294 << std::endl;
295 return;
296 }
297 m_wrapperList.push_back(std::reference_wrapper<VulkanWrapper>(wrapper));
298 m_nativeList.push_back((VulkanNative)wrapper);
299 }
300
301 template <class VulkanWrapper, class VulkanNative>
add(const VulkanWrapper & wrapper)302 void VulkanList<VulkanWrapper, VulkanNative>::add(const VulkanWrapper &wrapper)
303 {
304 if (m_wrapperList.size() != size_t(0))
305 {
306 std::cout << "This list cannot contain externally allocated objects"
307 << std::endl;
308 return;
309 }
310
311 m_constWrapperList.push_back(
312 std::reference_wrapper<const VulkanWrapper>(wrapper));
313 m_nativeList.push_back((VulkanNative)wrapper);
314 }
315
316 template <class VulkanWrapper, class VulkanNative>
size() const317 size_t VulkanList<VulkanWrapper, VulkanNative>::size() const
318 {
319 return (m_wrapperList.size() > 0) ? m_wrapperList.size()
320 : m_constWrapperList.size();
321 }
322
323 template <class VulkanWrapper, class VulkanNative>
324 const VulkanWrapper &
operator [](size_t idx) const325 VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx) const
326 {
327 if (idx < size())
328 {
329 // CHECK_LT(idx, size());
330 return (m_wrapperList.size() > 0) ? m_wrapperList[idx].get()
331 : m_constWrapperList[idx].get();
332 }
333 }
334
335 template <class VulkanWrapper, class VulkanNative>
operator [](size_t idx)336 VulkanWrapper &VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx)
337 {
338 // CHECK_LT(idx, m_wrapperList.size());
339 return m_wrapperList[idx].get();
340 }
341
342 template <class VulkanWrapper, class VulkanNative>
operator ()() const343 const VulkanNative *VulkanList<VulkanWrapper, VulkanNative>::operator()() const
344 {
345 return m_nativeList.data();
346 }
347
348 //////////////////////////////
349 // VulkanMap implementation //
350 //////////////////////////////
351
352 template <class VulkanKey, class VulkanValue>
VulkanMap(const VulkanMap & map)353 VulkanMap<VulkanKey, VulkanValue>::VulkanMap(const VulkanMap &map)
354 : m_map(map.m_map)
355 {}
356
357 template <class VulkanKey, class VulkanValue>
VulkanMap()358 VulkanMap<VulkanKey, VulkanValue>::VulkanMap()
359 {}
360
361 template <class VulkanKey, class VulkanValue>
~VulkanMap()362 VulkanMap<VulkanKey, VulkanValue>::~VulkanMap()
363 {}
364
365 template <class VulkanKey, class VulkanValue>
insert(const VulkanKey & key,VulkanValue & value)366 void VulkanMap<VulkanKey, VulkanValue>::insert(const VulkanKey &key,
367 VulkanValue &value)
368 {
369 m_map.insert(std::pair<VulkanKey, std::reference_wrapper<VulkanValue>>(
370 key, std::reference_wrapper<VulkanValue>(value)));
371 }
372
373 template <class VulkanKey, class VulkanValue>
374 const VulkanValue &
operator [](const VulkanKey & key) const375 VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key) const
376 {
377 return m_map.at(key);
378 }
379
380 template <class VulkanKey, class VulkanValue>
operator [](const VulkanKey & key)381 VulkanValue &VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key)
382 {
383 return m_map.at(key);
384 }
385
386 #endif // _vulkan_list_map_hpp_
387