external/vulkancts/framework/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  */
   4 namespace refdetails
   5 {
   6
   7 template<>
   8 void Deleter<VkDeviceMemory>::operator() (VkDeviceMemory obj) const
   9 {
  10         m_deviceIface->freeMemory(m_device, obj, m_allocator);
  11 }
  12
  13 template<>
  14 void Deleter<VkFence>::operator() (VkFence obj) const
  15 {
  16         m_deviceIface->destroyFence(m_device, obj, m_allocator);
  17 }
  18
  19 template<>
  20 void Deleter<VkSemaphore>::operator() (VkSemaphore obj) const
  21 {
  22         m_deviceIface->destroySemaphore(m_device, obj, m_allocator);
  23 }
  24
  25 template<>
  26 void Deleter<VkEvent>::operator() (VkEvent obj) const
  27 {
  28         m_deviceIface->destroyEvent(m_device, obj, m_allocator);
  29 }
  30
  31 template<>
  32 void Deleter<VkQueryPool>::operator() (VkQueryPool obj) const
  33 {
  34         m_deviceIface->destroyQueryPool(m_device, obj, m_allocator);
  35 }
  36
  37 template<>
  38 void Deleter<VkBuffer>::operator() (VkBuffer obj) const
  39 {
  40         m_deviceIface->destroyBuffer(m_device, obj, m_allocator);
  41 }
  42
  43 template<>
  44 void Deleter<VkBufferView>::operator() (VkBufferView obj) const
  45 {
  46         m_deviceIface->destroyBufferView(m_device, obj, m_allocator);
  47 }
  48
  49 template<>
  50 void Deleter<VkImage>::operator() (VkImage obj) const
  51 {
  52         m_deviceIface->destroyImage(m_device, obj, m_allocator);
  53 }
  54
  55 template<>
  56 void Deleter<VkImageView>::operator() (VkImageView obj) const
  57 {
  58         m_deviceIface->destroyImageView(m_device, obj, m_allocator);
  59 }
  60
  61 template<>
  62 void Deleter<VkShaderModule>::operator() (VkShaderModule obj) const
  63 {
  64         m_deviceIface->destroyShaderModule(m_device, obj, m_allocator);
  65 }
  66
  67 template<>
  68 void Deleter<VkPipelineCache>::operator() (VkPipelineCache obj) const
  69 {
  70         m_deviceIface->destroyPipelineCache(m_device, obj, m_allocator);
  71 }
  72
  73 template<>
  74 void Deleter<VkPipeline>::operator() (VkPipeline obj) const
  75 {
  76         m_deviceIface->destroyPipeline(m_device, obj, m_allocator);
  77 }
  78
  79 template<>
  80 void Deleter<VkPipelineLayout>::operator() (VkPipelineLayout obj) const
  81 {
  82         m_deviceIface->destroyPipelineLayout(m_device, obj, m_allocator);
  83 }
  84
  85 template<>
  86 void Deleter<VkSampler>::operator() (VkSampler obj) const
  87 {
  88         m_deviceIface->destroySampler(m_device, obj, m_allocator);
  89 }
  90
  91 template<>
  92 void Deleter<VkDescriptorSetLayout>::operator() (VkDescriptorSetLayout obj) const
  93 {
  94         m_deviceIface->destroyDescriptorSetLayout(m_device, obj, m_allocator);
  95 }
  96
  97 template<>
  98 void Deleter<VkDescriptorPool>::operator() (VkDescriptorPool obj) const
  99 {
 100         m_deviceIface->destroyDescriptorPool(m_device, obj, m_allocator);
 101 }
 102
 103 template<>
 104 void Deleter<VkFramebuffer>::operator() (VkFramebuffer obj) const
 105 {
 106         m_deviceIface->destroyFramebuffer(m_device, obj, m_allocator);
 107 }
 108
 109 template<>
 110 void Deleter<VkRenderPass>::operator() (VkRenderPass obj) const
 111 {
 112         m_deviceIface->destroyRenderPass(m_device, obj, m_allocator);
 113 }
 114
 115 template<>
 116 void Deleter<VkCommandPool>::operator() (VkCommandPool obj) const
 117 {
 118         m_deviceIface->destroyCommandPool(m_device, obj, m_allocator);
 119 }
 120
 121 template<>
 122 void Deleter<VkSwapchainKHR>::operator() (VkSwapchainKHR obj) const
 123 {
 124         m_deviceIface->destroySwapchainKHR(m_device, obj, m_allocator);
 125 }
 126
 127 template<>
 128 void Deleter<VkIndirectCommandsLayoutNVX>::operator() (VkIndirectCommandsLayoutNVX obj) const
 129 {
 130         m_deviceIface->destroyIndirectCommandsLayoutNVX(m_device, obj, m_allocator);
 131 }
 132
 133 template<>
 134 void Deleter<VkObjectTableNVX>::operator() (VkObjectTableNVX obj) const
 135 {
 136         m_deviceIface->destroyObjectTableNVX(m_device, obj, m_allocator);
 137 }
 138
 139 } // refdetails
 140
 141 Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 142 {
 143         VkInstance object = 0;
 144         VK_CHECK(vk.createInstance(pCreateInfo, pAllocator, &object));
 145         return Move<VkInstance>(check<VkInstance>(object), Deleter<VkInstance>(vk, object, pAllocator));
 146 }
 147
 148 Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 149 {
 150         VkDevice object = 0;
 151         VK_CHECK(vk.createDevice(physicalDevice, pCreateInfo, pAllocator, &object));
 152         return Move<VkDevice>(check<VkDevice>(object), Deleter<VkDevice>(vk, object, pAllocator));
 153 }
 154
 155 Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator)
 156 {
 157         VkDeviceMemory object = 0;
 158         VK_CHECK(vk.allocateMemory(device, pAllocateInfo, pAllocator, &object));
 159         return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device, pAllocator));
 160 }
 161
 162 Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 163 {
 164         VkFence object = 0;
 165         VK_CHECK(vk.createFence(device, pCreateInfo, pAllocator, &object));
 166         return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device, pAllocator));
 167 }
 168
 169 Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 170 {
 171         VkSemaphore object = 0;
 172         VK_CHECK(vk.createSemaphore(device, pCreateInfo, pAllocator, &object));
 173         return Move<VkSemaphore>(check<VkSemaphore>(object), Deleter<VkSemaphore>(vk, device, pAllocator));
 174 }
 175
 176 Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 177 {
 178         VkEvent object = 0;
 179         VK_CHECK(vk.createEvent(device, pCreateInfo, pAllocator, &object));
 180         return Move<VkEvent>(check<VkEvent>(object), Deleter<VkEvent>(vk, device, pAllocator));
 181 }
 182
 183 Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 184 {
 185         VkQueryPool object = 0;
 186         VK_CHECK(vk.createQueryPool(device, pCreateInfo, pAllocator, &object));
 187         return Move<VkQueryPool>(check<VkQueryPool>(object), Deleter<VkQueryPool>(vk, device, pAllocator));
 188 }
 189
 190 Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 191 {
 192         VkBuffer object = 0;
 193         VK_CHECK(vk.createBuffer(device, pCreateInfo, pAllocator, &object));
 194         return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device, pAllocator));
 195 }
 196
 197 Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 198 {
 199         VkBufferView object = 0;
 200         VK_CHECK(vk.createBufferView(device, pCreateInfo, pAllocator, &object));
 201         return Move<VkBufferView>(check<VkBufferView>(object), Deleter<VkBufferView>(vk, device, pAllocator));
 202 }
 203
 204 Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 205 {
 206         VkImage object = 0;
 207         VK_CHECK(vk.createImage(device, pCreateInfo, pAllocator, &object));
 208         return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device, pAllocator));
 209 }
 210
 211 Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 212 {
 213         VkImageView object = 0;
 214         VK_CHECK(vk.createImageView(device, pCreateInfo, pAllocator, &object));
 215         return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device, pAllocator));
 216 }
 217
 218 Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 219 {
 220         VkShaderModule object = 0;
 221         VK_CHECK(vk.createShaderModule(device, pCreateInfo, pAllocator, &object));
 222         return Move<VkShaderModule>(check<VkShaderModule>(object), Deleter<VkShaderModule>(vk, device, pAllocator));
 223 }
 224
 225 Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 226 {
 227         VkPipelineCache object = 0;
 228         VK_CHECK(vk.createPipelineCache(device, pCreateInfo, pAllocator, &object));
 229         return Move<VkPipelineCache>(check<VkPipelineCache>(object), Deleter<VkPipelineCache>(vk, device, pAllocator));
 230 }
 231
 232 Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 233 {
 234         VkPipelineLayout object = 0;
 235         VK_CHECK(vk.createPipelineLayout(device, pCreateInfo, pAllocator, &object));
 236         return Move<VkPipelineLayout>(check<VkPipelineLayout>(object), Deleter<VkPipelineLayout>(vk, device, pAllocator));
 237 }
 238
 239 Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 240 {
 241         VkSampler object = 0;
 242         VK_CHECK(vk.createSampler(device, pCreateInfo, pAllocator, &object));
 243         return Move<VkSampler>(check<VkSampler>(object), Deleter<VkSampler>(vk, device, pAllocator));
 244 }
 245
 246 Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 247 {
 248         VkDescriptorSetLayout object = 0;
 249         VK_CHECK(vk.createDescriptorSetLayout(device, pCreateInfo, pAllocator, &object));
 250         return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device, pAllocator));
 251 }
 252
 253 Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 254 {
 255         VkDescriptorPool object = 0;
 256         VK_CHECK(vk.createDescriptorPool(device, pCreateInfo, pAllocator, &object));
 257         return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device, pAllocator));
 258 }
 259
 260 Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 261 {
 262         VkFramebuffer object = 0;
 263         VK_CHECK(vk.createFramebuffer(device, pCreateInfo, pAllocator, &object));
 264         return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device, pAllocator));
 265 }
 266
 267 Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 268 {
 269         VkRenderPass object = 0;
 270         VK_CHECK(vk.createRenderPass(device, pCreateInfo, pAllocator, &object));
 271         return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device, pAllocator));
 272 }
 273
 274 Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 275 {
 276         VkCommandPool object = 0;
 277         VK_CHECK(vk.createCommandPool(device, pCreateInfo, pAllocator, &object));
 278         return Move<VkCommandPool>(check<VkCommandPool>(object), Deleter<VkCommandPool>(vk, device, pAllocator));
 279 }
 280
 281 Move<VkSwapchainKHR> createSwapchainKHR (const DeviceInterface& vk, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 282 {
 283         VkSwapchainKHR object = 0;
 284         VK_CHECK(vk.createSwapchainKHR(device, pCreateInfo, pAllocator, &object));
 285         return Move<VkSwapchainKHR>(check<VkSwapchainKHR>(object), Deleter<VkSwapchainKHR>(vk, device, pAllocator));
 286 }
 287
 288 Move<VkSurfaceKHR> createDisplayPlaneSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 289 {
 290         VkSurfaceKHR object = 0;
 291         VK_CHECK(vk.createDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 292         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 293 }
 294
 295 Move<VkSwapchainKHR> createSharedSwapchainsKHR (const DeviceInterface& vk, VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator)
 296 {
 297         VkSwapchainKHR object = 0;
 298         VK_CHECK(vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, &object));
 299         return Move<VkSwapchainKHR>(check<VkSwapchainKHR>(object), Deleter<VkSwapchainKHR>(vk, device, pAllocator));
 300 }
 301
 302 Move<VkSurfaceKHR> createXlibSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 303 {
 304         VkSurfaceKHR object = 0;
 305         VK_CHECK(vk.createXlibSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 306         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 307 }
 308
 309 Move<VkSurfaceKHR> createXcbSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 310 {
 311         VkSurfaceKHR object = 0;
 312         VK_CHECK(vk.createXcbSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 313         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 314 }
 315
 316 Move<VkSurfaceKHR> createWaylandSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 317 {
 318         VkSurfaceKHR object = 0;
 319         VK_CHECK(vk.createWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 320         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 321 }
 322
 323 Move<VkSurfaceKHR> createMirSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 324 {
 325         VkSurfaceKHR object = 0;
 326         VK_CHECK(vk.createMirSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 327         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 328 }
 329
 330 Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 331 {
 332         VkSurfaceKHR object = 0;
 333         VK_CHECK(vk.createAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 334         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 335 }
 336
 337 Move<VkSurfaceKHR> createWin32SurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 338 {
 339         VkSurfaceKHR object = 0;
 340         VK_CHECK(vk.createWin32SurfaceKHR(instance, pCreateInfo, pAllocator, &object));
 341         return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
 342 }
 343
 344 Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 345 {
 346         VkDebugReportCallbackEXT object = 0;
 347         VK_CHECK(vk.createDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, &object));
 348         return Move<VkDebugReportCallbackEXT>(check<VkDebugReportCallbackEXT>(object), Deleter<VkDebugReportCallbackEXT>(vk, instance, pAllocator));
 349 }
 350
 351 Move<VkIndirectCommandsLayoutNVX> createIndirectCommandsLayoutNVX (const DeviceInterface& vk, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 352 {
 353         VkIndirectCommandsLayoutNVX object = 0;
 354         VK_CHECK(vk.createIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, &object));
 355         return Move<VkIndirectCommandsLayoutNVX>(check<VkIndirectCommandsLayoutNVX>(object), Deleter<VkIndirectCommandsLayoutNVX>(vk, device, pAllocator));
 356 }
 357
 358 Move<VkObjectTableNVX> createObjectTableNVX (const DeviceInterface& vk, VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 359 {
 360         VkObjectTableNVX object = 0;
 361         VK_CHECK(vk.createObjectTableNVX(device, pCreateInfo, pAllocator, &object));
 362         return Move<VkObjectTableNVX>(check<VkObjectTableNVX>(object), Deleter<VkObjectTableNVX>(vk, device, pAllocator));
 363 }
 364