external/vulkancts/framework/vulkan/generated/vulkan/vkInstanceDriverImpl.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
   7 void InstanceDriver::destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator) const
   8 {
   9         m_vk.destroyInstance(instance, pAllocator);
  10 }
  11
  12 VkResult InstanceDriver::enumeratePhysicalDevices (VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const
  13 {
  14         return m_vk.enumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
  15 }
  16
  17 void InstanceDriver::getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const
  18 {
  19         m_vk.getPhysicalDeviceProperties(physicalDevice, pProperties);
  20 }
  21
  22 void InstanceDriver::getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) const
  23 {
  24         m_vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
  25 }
  26
  27 void InstanceDriver::getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const
  28 {
  29         m_vk.getPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
  30 }
  31
  32 void InstanceDriver::getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const
  33 {
  34         m_vk.getPhysicalDeviceFeatures(physicalDevice, pFeatures);
  35 }
  36
  37 void InstanceDriver::getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const
  38 {
  39         m_vk.getPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
  40 }
  41
  42 VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const
  43 {
  44         return m_vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
  45 }
  46
  47 VkResult InstanceDriver::createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) const
  48 {
  49         return m_vk.createDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
  50 }
  51
  52 VkResult InstanceDriver::enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) const
  53 {
  54         return m_vk.enumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
  55 }
  56
  57 VkResult InstanceDriver::enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) const
  58 {
  59         return m_vk.enumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
  60 }
  61
  62 void InstanceDriver::getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) const
  63 {
  64         m_vk.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
  65 }
  66
  67 VkResult InstanceDriver::createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
  68 {
  69         return m_vk.createAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
  70 }
  71
  72 VkResult InstanceDriver::getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) const
  73 {
  74         return m_vk.getPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
  75 }
  76
  77 VkResult InstanceDriver::getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) const
  78 {
  79         return m_vk.getPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
  80 }
  81
  82 VkResult InstanceDriver::getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) const
  83 {
  84         return m_vk.getDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
  85 }
  86
  87 VkResult InstanceDriver::getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) const
  88 {
  89         return m_vk.getDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
  90 }
  91
  92 VkResult InstanceDriver::createDisplayModeKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const
  93 {
  94         return m_vk.createDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
  95 }
  96
  97 VkResult InstanceDriver::getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const
  98 {
  99         return m_vk.getDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
 100 }
 101
 102 VkResult InstanceDriver::createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 103 {
 104         return m_vk.createDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 105 }
 106
 107 void InstanceDriver::destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) const
 108 {
 109         m_vk.destroySurfaceKHR(instance, surface, pAllocator);
 110 }
 111
 112 VkResult InstanceDriver::getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) const
 113 {
 114         return m_vk.getPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
 115 }
 116
 117 VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const
 118 {
 119         return m_vk.getPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
 120 }
 121
 122 VkResult InstanceDriver::getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) const
 123 {
 124         return m_vk.getPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
 125 }
 126
 127 VkResult InstanceDriver::getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const
 128 {
 129         return m_vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
 130 }
 131
 132 VkResult InstanceDriver::createViSurfaceNN (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 133 {
 134         return m_vk.createViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
 135 }
 136
 137 VkResult InstanceDriver::createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 138 {
 139         return m_vk.createWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 140 }
 141
 142 VkBool32 InstanceDriver::getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::WaylandDisplayPtr display) const
 143 {
 144         return m_vk.getPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
 145 }
 146
 147 VkResult InstanceDriver::createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 148 {
 149         return m_vk.createWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 150 }
 151
 152 VkBool32 InstanceDriver::getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) const
 153 {
 154         return m_vk.getPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
 155 }
 156
 157 VkResult InstanceDriver::createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 158 {
 159         return m_vk.createXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 160 }
 161
 162 VkBool32 InstanceDriver::getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID) const
 163 {
 164         return m_vk.getPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
 165 }
 166
 167 VkResult InstanceDriver::createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 168 {
 169         return m_vk.createXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 170 }
 171
 172 VkBool32 InstanceDriver::getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id) const
 173 {
 174         return m_vk.getPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
 175 }
 176
 177 VkResult InstanceDriver::createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 178 {
 179         return m_vk.createImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
 180 }
 181
 182 VkResult InstanceDriver::createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 183 {
 184         return m_vk.createStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
 185 }
 186
 187 VkResult InstanceDriver::createScreenSurfaceQNX (VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 188 {
 189         return m_vk.createScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
 190 }
 191
 192 VkBool32 InstanceDriver::getPhysicalDeviceScreenPresentationSupportQNX (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::QNXScreenWindowPtr window) const
 193 {
 194         return m_vk.getPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window);
 195 }
 196
 197 VkResult InstanceDriver::createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const
 198 {
 199         return m_vk.createDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
 200 }
 201
 202 void InstanceDriver::destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const
 203 {
 204         m_vk.destroyDebugReportCallbackEXT(instance, callback, pAllocator);
 205 }
 206
 207 void InstanceDriver::debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) const
 208 {
 209         m_vk.debugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
 210 }
 211
 212 VkResult InstanceDriver::getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const
 213 {
 214         return m_vk.getPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
 215 }
 216
 217 void InstanceDriver::getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const
 218 {
 219         vk::VkPhysicalDeviceProperties props;
 220         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 221         if (props.apiVersion >= VK_API_VERSION_1_1)
 222                 m_vk.getPhysicalDeviceFeatures2(physicalDevice, pFeatures);
 223         else
 224                 m_vk.getPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
 225 }
 226
 227 void InstanceDriver::getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const
 228 {
 229         vk::VkPhysicalDeviceProperties props;
 230         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 231         if (props.apiVersion >= VK_API_VERSION_1_1)
 232                 m_vk.getPhysicalDeviceProperties2(physicalDevice, pProperties);
 233         else
 234                 m_vk.getPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
 235 }
 236
 237 void InstanceDriver::getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const
 238 {
 239         vk::VkPhysicalDeviceProperties props;
 240         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 241         if (props.apiVersion >= VK_API_VERSION_1_1)
 242                 m_vk.getPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
 243         else
 244                 m_vk.getPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
 245 }
 246
 247 VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const
 248 {
 249         vk::VkPhysicalDeviceProperties props;
 250         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 251         if (props.apiVersion >= VK_API_VERSION_1_1)
 252                 return m_vk.getPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
 253         else
 254                 return m_vk.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
 255 }
 256
 257 void InstanceDriver::getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const
 258 {
 259         vk::VkPhysicalDeviceProperties props;
 260         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 261         if (props.apiVersion >= VK_API_VERSION_1_1)
 262                 m_vk.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 263         else
 264                 m_vk.getPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 265 }
 266
 267 void InstanceDriver::getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const
 268 {
 269         vk::VkPhysicalDeviceProperties props;
 270         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 271         if (props.apiVersion >= VK_API_VERSION_1_1)
 272                 m_vk.getPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
 273         else
 274                 m_vk.getPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
 275 }
 276
 277 void InstanceDriver::getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const
 278 {
 279         vk::VkPhysicalDeviceProperties props;
 280         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 281         if (props.apiVersion >= VK_API_VERSION_1_1)
 282                 m_vk.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
 283         else
 284                 m_vk.getPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
 285 }
 286
 287 void InstanceDriver::getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const
 288 {
 289         vk::VkPhysicalDeviceProperties props;
 290         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 291         if (props.apiVersion >= VK_API_VERSION_1_1)
 292                 m_vk.getPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
 293         else
 294                 m_vk.getPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
 295 }
 296
 297 void InstanceDriver::getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const
 298 {
 299         vk::VkPhysicalDeviceProperties props;
 300         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 301         if (props.apiVersion >= VK_API_VERSION_1_1)
 302                 m_vk.getPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
 303         else
 304                 m_vk.getPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
 305 }
 306
 307 void InstanceDriver::getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const
 308 {
 309         vk::VkPhysicalDeviceProperties props;
 310         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 311         if (props.apiVersion >= VK_API_VERSION_1_1)
 312                 m_vk.getPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
 313         else
 314                 m_vk.getPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
 315 }
 316
 317 VkResult InstanceDriver::releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display) const
 318 {
 319         return m_vk.releaseDisplayEXT(physicalDevice, display);
 320 }
 321
 322 VkResult InstanceDriver::acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display) const
 323 {
 324         return m_vk.acquireXlibDisplayEXT(physicalDevice, dpy, display);
 325 }
 326
 327 VkResult InstanceDriver::getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay) const
 328 {
 329         return m_vk.getRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
 330 }
 331
 332 VkResult InstanceDriver::acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display) const
 333 {
 334         return m_vk.acquireWinrtDisplayNV(physicalDevice, display);
 335 }
 336
 337 VkResult InstanceDriver::getWinrtDisplayNV (VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) const
 338 {
 339         return m_vk.getWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
 340 }
 341
 342 VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const
 343 {
 344         return m_vk.getPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
 345 }
 346
 347 VkResult InstanceDriver::enumeratePhysicalDeviceGroups (VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const
 348 {
 349         return m_vk.enumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
 350 }
 351
 352 VkResult InstanceDriver::getPhysicalDevicePresentRectanglesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) const
 353 {
 354         return m_vk.getPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
 355 }
 356
 357 VkResult InstanceDriver::createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 358 {
 359         return m_vk.createIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
 360 }
 361
 362 VkResult InstanceDriver::createMacOSSurfaceMVK (VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 363 {
 364         return m_vk.createMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
 365 }
 366
 367 VkResult InstanceDriver::createMetalSurfaceEXT (VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 368 {
 369         return m_vk.createMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
 370 }
 371
 372 void InstanceDriver::getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) const
 373 {
 374         m_vk.getPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
 375 }
 376
 377 VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const
 378 {
 379         return m_vk.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
 380 }
 381
 382 VkResult InstanceDriver::getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const
 383 {
 384         return m_vk.getPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
 385 }
 386
 387 VkResult InstanceDriver::getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) const
 388 {
 389         return m_vk.getPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
 390 }
 391
 392 VkResult InstanceDriver::getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const
 393 {
 394         return m_vk.getPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
 395 }
 396
 397 VkResult InstanceDriver::getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const
 398 {
 399         return m_vk.getDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
 400 }
 401
 402 VkResult InstanceDriver::getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const
 403 {
 404         return m_vk.getDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
 405 }
 406
 407 VkResult InstanceDriver::getPhysicalDeviceCalibrateableTimeDomainsEXT (VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) const
 408 {
 409         return m_vk.getPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
 410 }
 411
 412 VkResult InstanceDriver::createDebugUtilsMessengerEXT (VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) const
 413 {
 414         return m_vk.createDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
 415 }
 416
 417 void InstanceDriver::destroyDebugUtilsMessengerEXT (VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) const
 418 {
 419         m_vk.destroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
 420 }
 421
 422 void InstanceDriver::submitDebugUtilsMessageEXT (VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const
 423 {
 424         m_vk.submitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
 425 }
 426
 427 VkResult InstanceDriver::getPhysicalDeviceCooperativeMatrixPropertiesNV (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) const
 428 {
 429         return m_vk.getPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
 430 }
 431
 432 VkResult InstanceDriver::getPhysicalDeviceSurfacePresentModes2EXT (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const
 433 {
 434         return m_vk.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
 435 }
 436
 437 VkResult InstanceDriver::enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const
 438 {
 439         return m_vk.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
 440 }
 441
 442 void InstanceDriver::getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) const
 443 {
 444         m_vk.getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
 445 }
 446
 447 VkResult InstanceDriver::createHeadlessSurfaceEXT (VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const
 448 {
 449         return m_vk.createHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
 450 }
 451
 452 VkResult InstanceDriver::getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV (VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) const
 453 {
 454         return m_vk.getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
 455 }
 456
 457 VkResult InstanceDriver::getPhysicalDeviceToolProperties (VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) const
 458 {
 459         vk::VkPhysicalDeviceProperties props;
 460         m_vk.getPhysicalDeviceProperties(physicalDevice, &props);
 461         if (props.apiVersion >= VK_API_VERSION_1_1)
 462                 return m_vk.getPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
 463         else
 464                 return m_vk.getPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
 465 }
 466
 467 VkResult InstanceDriver::getPhysicalDeviceFragmentShadingRatesKHR (VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const
 468 {
 469         return m_vk.getPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
 470 }
 471
 472 VkResult InstanceDriver::getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const
 473 {
 474         return m_vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities);
 475 }
 476
 477 VkResult InstanceDriver::getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const
 478 {
 479         return m_vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
 480 }
 481
 482 VkResult InstanceDriver::acquireDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const
 483 {
 484         return m_vk.acquireDrmDisplayEXT(physicalDevice, drmFd, display);
 485 }
 486
 487 VkResult InstanceDriver::getDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) const
 488 {
 489         return m_vk.getDrmDisplayEXT(physicalDevice, drmFd, connectorId, display);
 490 }