external/vulkancts/framework/vulkan/generated/vulkan/vkRefUtilImpl.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  * This file was generated by /scripts/gen_framework.py
   4  */
   5
   6 namespace refdetails
   7 {
   8
   9 template<>
  10 void Deleter<VkDeviceMemory>::operator() (VkDeviceMemory obj) const
  11 {
  12         m_deviceIface->freeMemory(m_device, obj, m_allocator);
  13 }
  14
  15 template<>
  16 void Deleter<VkFence>::operator() (VkFence obj) const
  17 {
  18         m_deviceIface->destroyFence(m_device, obj, m_allocator);
  19 }
  20
  21 template<>
  22 void Deleter<VkSemaphore>::operator() (VkSemaphore obj) const
  23 {
  24         m_deviceIface->destroySemaphore(m_device, obj, m_allocator);
  25 }
  26
  27 template<>
  28 void Deleter<VkEvent>::operator() (VkEvent obj) const
  29 {
  30         m_deviceIface->destroyEvent(m_device, obj, m_allocator);
  31 }
  32
  33 template<>
  34 void Deleter<VkQueryPool>::operator() (VkQueryPool obj) const
  35 {
  36         m_deviceIface->destroyQueryPool(m_device, obj, m_allocator);
  37 }
  38
  39 template<>
  40 void Deleter<VkBuffer>::operator() (VkBuffer obj) const
  41 {
  42         m_deviceIface->destroyBuffer(m_device, obj, m_allocator);
  43 }
  44
  45 template<>
  46 void Deleter<VkBufferView>::operator() (VkBufferView obj) const
  47 {
  48         m_deviceIface->destroyBufferView(m_device, obj, m_allocator);
  49 }
  50
  51 template<>
  52 void Deleter<VkImage>::operator() (VkImage obj) const
  53 {
  54         m_deviceIface->destroyImage(m_device, obj, m_allocator);
  55 }
  56
  57 template<>
  58 void Deleter<VkImageView>::operator() (VkImageView obj) const
  59 {
  60         m_deviceIface->destroyImageView(m_device, obj, m_allocator);
  61 }
  62
  63 template<>
  64 void Deleter<VkShaderModule>::operator() (VkShaderModule obj) const
  65 {
  66         m_deviceIface->destroyShaderModule(m_device, obj, m_allocator);
  67 }
  68
  69 template<>
  70 void Deleter<VkPipelineCache>::operator() (VkPipelineCache obj) const
  71 {
  72         m_deviceIface->destroyPipelineCache(m_device, obj, m_allocator);
  73 }
  74
  75 template<>
  76 void Deleter<VkPipeline>::operator() (VkPipeline obj) const
  77 {
  78         m_deviceIface->destroyPipeline(m_device, obj, m_allocator);
  79 }
  80
  81 template<>
  82 void Deleter<VkPipelineLayout>::operator() (VkPipelineLayout obj) const
  83 {
  84         m_deviceIface->destroyPipelineLayout(m_device, obj, m_allocator);
  85 }
  86
  87 template<>
  88 void Deleter<VkSampler>::operator() (VkSampler obj) const
  89 {
  90         m_deviceIface->destroySampler(m_device, obj, m_allocator);
  91 }
  92
  93 template<>
  94 void Deleter<VkDescriptorSetLayout>::operator() (VkDescriptorSetLayout obj) const
  95 {
  96         m_deviceIface->destroyDescriptorSetLayout(m_device, obj, m_allocator);
  97 }
  98
  99 template<>
 100 void Deleter<VkDescriptorPool>::operator() (VkDescriptorPool obj) const
 101 {
 102         m_deviceIface->destroyDescriptorPool(m_device, obj, m_allocator);
 103 }
 104
 105 template<>
 106 void Deleter<VkFramebuffer>::operator() (VkFramebuffer obj) const
 107 {
 108         m_deviceIface->destroyFramebuffer(m_device, obj, m_allocator);
 109 }
 110
 111 template<>
 112 void Deleter<VkRenderPass>::operator() (VkRenderPass obj) const
 113 {
 114         m_deviceIface->destroyRenderPass(m_device, obj, m_allocator);
 115 }
 116
 117 template<>
 118 void Deleter<VkCommandPool>::operator() (VkCommandPool obj) const
 119 {
 120         m_deviceIface->destroyCommandPool(m_device, obj, m_allocator);
 121 }
 122
 123 template<>
 124 void Deleter<VkSwapchainKHR>::operator() (VkSwapchainKHR obj) const
 125 {
 126         m_deviceIface->destroySwapchainKHR(m_device, obj, m_allocator);
 127 }
 128
 129 template<>
 130 void Deleter<VkIndirectCommandsLayoutNV>::operator() (VkIndirectCommandsLayoutNV obj) const
 131 {
 132         m_deviceIface->destroyIndirectCommandsLayoutNV(m_device, obj, m_allocator);
 133 }
 134
 135 template<>
 136 void Deleter<VkDescriptorUpdateTemplate>::operator() (VkDescriptorUpdateTemplate obj) const
 137 {
 138         m_deviceIface->destroyDescriptorUpdateTemplate(m_device, obj, m_allocator);
 139 }
 140
 141 template<>
 142 void Deleter<VkSamplerYcbcrConversion>::operator() (VkSamplerYcbcrConversion obj) const
 143 {
 144         m_deviceIface->destroySamplerYcbcrConversion(m_device, obj, m_allocator);
 145 }
 146
 147 template<>
 148 void Deleter<VkValidationCacheEXT>::operator() (VkValidationCacheEXT obj) const
 149 {
 150         m_deviceIface->destroyValidationCacheEXT(m_device, obj, m_allocator);
 151 }
 152
 153 template<>
 154 void Deleter<VkAccelerationStructureKHR>::operator() (VkAccelerationStructureKHR obj) const
 155 {
 156         m_deviceIface->destroyAccelerationStructureKHR(m_device, obj, m_allocator);
 157 }
 158
 159 template<>
 160 void Deleter<VkAccelerationStructureNV>::operator() (VkAccelerationStructureNV obj) const
 161 {
 162         m_deviceIface->destroyAccelerationStructureNV(m_device, obj, m_allocator);
 163 }
 164
 165 template<>
 166 void Deleter<VkDeferredOperationKHR>::operator() (VkDeferredOperationKHR obj) const
 167 {
 168         m_deviceIface->destroyDeferredOperationKHR(m_device, obj, m_allocator);
 169 }
 170
 171 template<>
 172 void Deleter<VkPrivateDataSlot>::operator() (VkPrivateDataSlot obj) const
 173 {
 174         m_deviceIface->destroyPrivateDataSlot(m_device, obj, m_allocator);
 175 }
 176
 177 template<>
 178 void Deleter<VkVideoSessionKHR>::operator() (VkVideoSessionKHR obj) const
 179 {
 180         m_deviceIface->destroyVideoSessionKHR(m_device, obj, m_allocator);
 181 }
 182
 183 template<>
 184 void Deleter<VkVideoSessionParametersKHR>::operator() (VkVideoSessionParametersKHR obj) const
 185 {
 186         m_deviceIface->destroyVideoSessionParametersKHR(m_device, obj, m_allocator);
 187 }
 188
 189 template<>
 190 void Deleter<VkCuModuleNVX>::operator() (VkCuModuleNVX obj) const
 191 {
 192         m_deviceIface->destroyCuModuleNVX(m_device, obj, m_allocator);
 193 }
 194
 195 template<>
 196 void Deleter<VkCuFunctionNVX>::operator() (VkCuFunctionNVX obj) const
 197 {
 198         m_deviceIface->destroyCuFunctionNVX(m_device, obj, m_allocator);
 199 }
 200
 201 template<>
 202 void Deleter<VkBufferCollectionFUCHSIA>::operator() (VkBufferCollectionFUCHSIA obj) const
 203 {
 204         m_deviceIface->destroyBufferCollectionFUCHSIA(m_device, obj, m_allocator);
 205 }
 206
 207 } // refdetails
 208
 209 Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 210 {
 211         VkInstance object = 0;
 212         VK_CHECK(vk.createInstance(pCreateInfo, pAllocator, &object));
 213         return Move<VkInstance>(check<VkInstance>(object), Deleter<VkInstance>(vk, object, pAllocator));
 214 }
 215
 216 Move<VkDevice> createDevice (const PlatformInterface& vkp, VkInstance instance, const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 217 {
 218         VkDevice object = 0;
 219         VK_CHECK(vk.createDevice(physicalDevice, pCreateInfo, pAllocator, &object));
 220         return Move<VkDevice>(check<VkDevice>(object), Deleter<VkDevice>(vkp, instance, object, pAllocator));
 221 }
 222
 223 Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator)
 224 {
 225         VkDeviceMemory object = 0;
 226         VK_CHECK(vk.allocateMemory(device, pAllocateInfo, pAllocator, &object));
 227         return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device, pAllocator));
 228 }
 229
 230 Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 231 {
 232         VkFence object = 0;
 233         VK_CHECK(vk.createFence(device, pCreateInfo, pAllocator, &object));
 234         return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device, pAllocator));
 235 }
 236
 237 Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 238 {
 239         VkSemaphore object = 0;
 240         VK_CHECK(vk.createSemaphore(device, pCreateInfo, pAllocator, &object));
 241         return Move<VkSemaphore>(check<VkSemaphore>(object), Deleter<VkSemaphore>(vk, device, pAllocator));
 242 }
 243
 244 Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 245 {
 246         VkEvent object = 0;
 247         VK_CHECK(vk.createEvent(device, pCreateInfo, pAllocator, &object));
 248         return Move<VkEvent>(check<VkEvent>(object), Deleter<VkEvent>(vk, device, pAllocator));
 249 }
 250
 251 Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 252 {
 253         VkQueryPool object = 0;
 254         VK_CHECK(vk.createQueryPool(device, pCreateInfo, pAllocator, &object));
 255         return Move<VkQueryPool>(check<VkQueryPool>(object), Deleter<VkQueryPool>(vk, device, pAllocator));
 256 }
 257
 258 Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 259 {
 260         VkBuffer object = 0;
 261         VK_CHECK(vk.createBuffer(device, pCreateInfo, pAllocator, &object));
 262         return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device, pAllocator));
 263 }
 264
 265 Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 266 {
 267         VkBufferView object = 0;
 268         VK_CHECK(vk.createBufferView(device, pCreateInfo, pAllocator, &object));
 269         return Move<VkBufferView>(check<VkBufferView>(object), Deleter<VkBufferView>(vk, device, pAllocator));
 270 }
 271
 272 Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 273 {
 274         VkImage object = 0;
 275         VK_CHECK(vk.createImage(device, pCreateInfo, pAllocator, &object));
 276         return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device, pAllocator));
 277 }
 278
 279 Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 280 {
 281         VkImageView object = 0;
 282         VK_CHECK(vk.createImageView(device, pCreateInfo, pAllocator, &object));
 283         return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device, pAllocator));
 284 }
 285
 286 Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 287 {
 288         VkShaderModule object = 0;
 289         VK_CHECK(vk.createShaderModule(device, pCreateInfo, pAllocator, &object));
 290         return Move<VkShaderModule>(check<VkShaderModule>(object), Deleter<VkShaderModule>(vk, device, pAllocator));
 291 }
 292
 293 Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 294 {
 295         VkPipelineCache object = 0;
 296         VK_CHECK(vk.createPipelineCache(device, pCreateInfo, pAllocator, &object));
 297         return Move<VkPipelineCache>(check<VkPipelineCache>(object), Deleter<VkPipelineCache>(vk, device, pAllocator));
 298 }
 299
 300 Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 301 {
 302         VkPipelineLayout object = 0;
 303         VK_CHECK(vk.createPipelineLayout(device, pCreateInfo, pAllocator, &object));
 304         return Move<VkPipelineLayout>(check<VkPipelineLayout>(object), Deleter<VkPipelineLayout>(vk, device, pAllocator));
 305 }
 306
 307 Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 308 {
 309         VkSampler object = 0;
 310         VK_CHECK(vk.createSampler(device, pCreateInfo, pAllocator, &object));
 311         return Move<VkSampler>(check<VkSampler>(object), Deleter<VkSampler>(vk, device, pAllocator));
 312 }
 313
 314 Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 315 {
 316         VkDescriptorSetLayout object = 0;
 317         VK_CHECK(vk.createDescriptorSetLayout(device, pCreateInfo, pAllocator, &object));
 318         return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device, pAllocator));
 319 }
 320
 321 Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 322 {
 323         VkDescriptorPool object = 0;
 324         VK_CHECK(vk.createDescriptorPool(device, pCreateInfo, pAllocator, &object));
 325         return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device, pAllocator));
 326 }
 327
 328 Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 329 {
 330         VkFramebuffer object = 0;
 331         VK_CHECK(vk.createFramebuffer(device, pCreateInfo, pAllocator, &object));
 332         return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device, pAllocator));
 333 }
 334
 335 Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 336 {
 337         VkRenderPass object = 0;
 338         VK_CHECK(vk.createRenderPass(device, pCreateInfo, pAllocator, &object));
 339         return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device, pAllocator));
 340 }
 341
 342 Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 343 {
 344         VkCommandPool object = 0;
 345         VK_CHECK(vk.createCommandPool(device, pCreateInfo, pAllocator, &object));
 346         return Move<VkCommandPool>(check<VkCommandPool>(object), Deleter<VkCommandPool>(vk, device, pAllocator));
 347 }
 348
 349 Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 350 {
 351         VkSurfaceKHR object = 0;
 352         VK_CHECK(vk.createAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 353         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 354 }
 355
 356 Move<VkSurfaceKHR> createDisplayPlaneSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 357 {
 358         VkSurfaceKHR object = 0;
 359         VK_CHECK(vk.createDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 360         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 361 }
 362
 363 Move<VkSwapchainKHR> createSharedSwapchainsKHR (const DeviceInterface& vk, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator)
 364 {
 365         VkSwapchainKHR object = 0;
 366         VK_CHECK(vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, &object));
 367         return Move<VkSwapchainKHR>(check<VkSwapchainKHR>(object), Deleter<VkSwapchainKHR>(vk, device, pAllocator));
 368 }
 369
 370 Move<VkSwapchainKHR> createSwapchainKHR (const DeviceInterface& vk, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 371 {
 372         VkSwapchainKHR object = 0;
 373         VK_CHECK(vk.createSwapchainKHR(device, pCreateInfo, pAllocator, &object));
 374         return Move<VkSwapchainKHR>(check<VkSwapchainKHR>(object), Deleter<VkSwapchainKHR>(vk, device, pAllocator));
 375 }
 376
 377 Move<VkSurfaceKHR> createViSurfaceNN (const InstanceInterface& vk, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 378 {
 379         VkSurfaceKHR object = 0;
 380         VK_CHECK(vk.createViSurfaceNN(instance, pCreateInfo, pAllocator, &object));
 381         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 382 }
 383
 384 Move<VkSurfaceKHR> createWaylandSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 385 {
 386         VkSurfaceKHR object = 0;
 387         VK_CHECK(vk.createWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 388         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 389 }
 390
 391 Move<VkSurfaceKHR> createWin32SurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 392 {
 393         VkSurfaceKHR object = 0;
 394         VK_CHECK(vk.createWin32SurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 395         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 396 }
 397
 398 Move<VkSurfaceKHR> createXlibSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 399 {
 400         VkSurfaceKHR object = 0;
 401         VK_CHECK(vk.createXlibSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 402         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 403 }
 404
 405 Move<VkSurfaceKHR> createXcbSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 406 {
 407         VkSurfaceKHR object = 0;
 408         VK_CHECK(vk.createXcbSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 409         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 410 }
 411
 412 Move<VkSurfaceKHR> createImagePipeSurfaceFUCHSIA (const InstanceInterface& vk, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 413 {
 414         VkSurfaceKHR object = 0;
 415         VK_CHECK(vk.createImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, &object));
 416         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 417 }
 418
 419 Move<VkSurfaceKHR> createStreamDescriptorSurfaceGGP (const InstanceInterface& vk, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 420 {
 421         VkSurfaceKHR object = 0;
 422         VK_CHECK(vk.createStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, &object));
 423         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 424 }
 425
 426 Move<VkSurfaceKHR> createScreenSurfaceQNX (const InstanceInterface& vk, VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 427 {
 428         VkSurfaceKHR object = 0;
 429         VK_CHECK(vk.createScreenSurfaceQNX(instance, pCreateInfo, pAllocator, &object));
 430         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 431 }
 432
 433 Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 434 {
 435         VkDebugReportCallbackEXT object = 0;
 436         VK_CHECK(vk.createDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, &object));
 437         return Move<VkDebugReportCallbackEXT>(check<VkDebugReportCallbackEXT>(object), Deleter<VkDebugReportCallbackEXT>(vk, instance, pAllocator));
 438 }
 439
 440 Move<VkIndirectCommandsLayoutNV> createIndirectCommandsLayoutNV (const DeviceInterface& vk, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 441 {
 442         VkIndirectCommandsLayoutNV object = 0;
 443         VK_CHECK(vk.createIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, &object));
 444         return Move<VkIndirectCommandsLayoutNV>(check<VkIndirectCommandsLayoutNV>(object), Deleter<VkIndirectCommandsLayoutNV>(vk, device, pAllocator));
 445 }
 446
 447 Move<VkDescriptorUpdateTemplate> createDescriptorUpdateTemplate (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 448 {
 449         VkDescriptorUpdateTemplate object = 0;
 450         VK_CHECK(vk.createDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, &object));
 451         return Move<VkDescriptorUpdateTemplate>(check<VkDescriptorUpdateTemplate>(object), Deleter<VkDescriptorUpdateTemplate>(vk, device, pAllocator));
 452 }
 453
 454 Move<VkSurfaceKHR> createIOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 455 {
 456         VkSurfaceKHR object = 0;
 457         VK_CHECK(vk.createIOSSurfaceMVK(instance, pCreateInfo, pAllocator, &object));
 458         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 459 }
 460
 461 Move<VkSurfaceKHR> createMacOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 462 {
 463         VkSurfaceKHR object = 0;
 464         VK_CHECK(vk.createMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, &object));
 465         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 466 }
 467
 468 Move<VkSurfaceKHR> createMetalSurfaceEXT (const InstanceInterface& vk, VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 469 {
 470         VkSurfaceKHR object = 0;
 471         VK_CHECK(vk.createMetalSurfaceEXT(instance, pCreateInfo, pAllocator, &object));
 472         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 473 }
 474
 475 Move<VkSamplerYcbcrConversion> createSamplerYcbcrConversion (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 476 {
 477         VkSamplerYcbcrConversion object = 0;
 478         VK_CHECK(vk.createSamplerYcbcrConversion(device, pCreateInfo, pAllocator, &object));
 479         return Move<VkSamplerYcbcrConversion>(check<VkSamplerYcbcrConversion>(object), Deleter<VkSamplerYcbcrConversion>(vk, device, pAllocator));
 480 }
 481
 482 Move<VkValidationCacheEXT> createValidationCacheEXT (const DeviceInterface& vk, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 483 {
 484         VkValidationCacheEXT object = 0;
 485         VK_CHECK(vk.createValidationCacheEXT(device, pCreateInfo, pAllocator, &object));
 486         return Move<VkValidationCacheEXT>(check<VkValidationCacheEXT>(object), Deleter<VkValidationCacheEXT>(vk, device, pAllocator));
 487 }
 488
 489 Move<VkDebugUtilsMessengerEXT> createDebugUtilsMessengerEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 490 {
 491         VkDebugUtilsMessengerEXT object = 0;
 492         VK_CHECK(vk.createDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, &object));
 493         return Move<VkDebugUtilsMessengerEXT>(check<VkDebugUtilsMessengerEXT>(object), Deleter<VkDebugUtilsMessengerEXT>(vk, instance, pAllocator));
 494 }
 495
 496 Move<VkRenderPass> createRenderPass2 (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 497 {
 498         VkRenderPass object = 0;
 499         VK_CHECK(vk.createRenderPass2(device, pCreateInfo, pAllocator, &object));
 500         return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device, pAllocator));
 501 }
 502
 503 Move<VkAccelerationStructureNV> createAccelerationStructureNV (const DeviceInterface& vk, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 504 {
 505         VkAccelerationStructureNV object = 0;
 506         VK_CHECK(vk.createAccelerationStructureNV(device, pCreateInfo, pAllocator, &object));
 507         return Move<VkAccelerationStructureNV>(check<VkAccelerationStructureNV>(object), Deleter<VkAccelerationStructureNV>(vk, device, pAllocator));
 508 }
 509
 510 Move<VkSurfaceKHR> createHeadlessSurfaceEXT (const InstanceInterface& vk, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 511 {
 512         VkSurfaceKHR object = 0;
 513         VK_CHECK(vk.createHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, &object));
 514         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 515 }
 516
 517 Move<VkAccelerationStructureKHR> createAccelerationStructureKHR (const DeviceInterface& vk, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 518 {
 519         VkAccelerationStructureKHR object = 0;
 520         VK_CHECK(vk.createAccelerationStructureKHR(device, pCreateInfo, pAllocator, &object));
 521         return Move<VkAccelerationStructureKHR>(check<VkAccelerationStructureKHR>(object), Deleter<VkAccelerationStructureKHR>(vk, device, pAllocator));
 522 }
 523
 524 Move<VkDeferredOperationKHR> createDeferredOperationKHR (const DeviceInterface& vk, VkDevice device, const VkAllocationCallbacks* pAllocator)
 525 {
 526         VkDeferredOperationKHR object = 0;
 527         VK_CHECK(vk.createDeferredOperationKHR(device, pAllocator, &object));
 528         return Move<VkDeferredOperationKHR>(check<VkDeferredOperationKHR>(object), Deleter<VkDeferredOperationKHR>(vk, device, pAllocator));
 529 }
 530
 531 Move<VkPrivateDataSlot> createPrivateDataSlot (const DeviceInterface& vk, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 532 {
 533         VkPrivateDataSlot object = 0;
 534         VK_CHECK(vk.createPrivateDataSlot(device, pCreateInfo, pAllocator, &object));
 535         return Move<VkPrivateDataSlot>(check<VkPrivateDataSlot>(object), Deleter<VkPrivateDataSlot>(vk, device, pAllocator));
 536 }
 537
 538 Move<VkVideoSessionKHR> createVideoSessionKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 539 {
 540         VkVideoSessionKHR object = 0;
 541         VK_CHECK(vk.createVideoSessionKHR(device, pCreateInfo, pAllocator, &object));
 542         return Move<VkVideoSessionKHR>(check<VkVideoSessionKHR>(object), Deleter<VkVideoSessionKHR>(vk, device, pAllocator));
 543 }
 544
 545 Move<VkVideoSessionParametersKHR> createVideoSessionParametersKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 546 {
 547         VkVideoSessionParametersKHR object = 0;
 548         VK_CHECK(vk.createVideoSessionParametersKHR(device, pCreateInfo, pAllocator, &object));
 549         return Move<VkVideoSessionParametersKHR>(check<VkVideoSessionParametersKHR>(object), Deleter<VkVideoSessionParametersKHR>(vk, device, pAllocator));
 550 }
 551
 552 Move<VkCuModuleNVX> createCuModuleNVX (const DeviceInterface& vk, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 553 {
 554         VkCuModuleNVX object = 0;
 555         VK_CHECK(vk.createCuModuleNVX(device, pCreateInfo, pAllocator, &object));
 556         return Move<VkCuModuleNVX>(check<VkCuModuleNVX>(object), Deleter<VkCuModuleNVX>(vk, device, pAllocator));
 557 }
 558
 559 Move<VkCuFunctionNVX> createCuFunctionNVX (const DeviceInterface& vk, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 560 {
 561         VkCuFunctionNVX object = 0;
 562         VK_CHECK(vk.createCuFunctionNVX(device, pCreateInfo, pAllocator, &object));
 563         return Move<VkCuFunctionNVX>(check<VkCuFunctionNVX>(object), Deleter<VkCuFunctionNVX>(vk, device, pAllocator));
 564 }
 565
 566 Move<VkBufferCollectionFUCHSIA> createBufferCollectionFUCHSIA (const DeviceInterface& vk, VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 567 {
 568         VkBufferCollectionFUCHSIA object = 0;
 569         VK_CHECK(vk.createBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, &object));
 570         return Move<VkBufferCollectionFUCHSIA>(check<VkBufferCollectionFUCHSIA>(object), Deleter<VkBufferCollectionFUCHSIA>(vk, device, pAllocator));
 571 }
 572