external/vulkancts/framework/vulkan/generated/vulkan/vkNullDriverImpl.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 VKAPI_ATTR VkResult VKAPI_CALL createInstance (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
   7 {
   8         DE_UNREF(pAllocator);
   9         VK_NULL_RETURN((*pInstance = allocateHandle<Instance, VkInstance>(pCreateInfo, pAllocator)));
  10 }
  11
  12 VKAPI_ATTR VkResult VKAPI_CALL createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
  13 {
  14         DE_UNREF(pAllocator);
  15         VK_NULL_RETURN((*pDevice = allocateHandle<Device, VkDevice>(physicalDevice, pCreateInfo, pAllocator)));
  16 }
  17
  18 VKAPI_ATTR VkResult VKAPI_CALL createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
  19 {
  20         DE_UNREF(pAllocator);
  21         VK_NULL_RETURN((*pFence = allocateNonDispHandle<Fence, VkFence>(device, pCreateInfo, pAllocator)));
  22 }
  23
  24 VKAPI_ATTR VkResult VKAPI_CALL createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
  25 {
  26         DE_UNREF(pAllocator);
  27         VK_NULL_RETURN((*pSemaphore = allocateNonDispHandle<Semaphore, VkSemaphore>(device, pCreateInfo, pAllocator)));
  28 }
  29
  30 VKAPI_ATTR VkResult VKAPI_CALL createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
  31 {
  32         DE_UNREF(pAllocator);
  33         VK_NULL_RETURN((*pEvent = allocateNonDispHandle<Event, VkEvent>(device, pCreateInfo, pAllocator)));
  34 }
  35
  36 VKAPI_ATTR VkResult VKAPI_CALL createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
  37 {
  38         DE_UNREF(pAllocator);
  39         VK_NULL_RETURN((*pQueryPool = allocateNonDispHandle<QueryPool, VkQueryPool>(device, pCreateInfo, pAllocator)));
  40 }
  41
  42 VKAPI_ATTR VkResult VKAPI_CALL createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
  43 {
  44         DE_UNREF(pAllocator);
  45         VK_NULL_RETURN((*pBuffer = allocateNonDispHandle<Buffer, VkBuffer>(device, pCreateInfo, pAllocator)));
  46 }
  47
  48 VKAPI_ATTR VkResult VKAPI_CALL createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
  49 {
  50         DE_UNREF(pAllocator);
  51         VK_NULL_RETURN((*pView = allocateNonDispHandle<BufferView, VkBufferView>(device, pCreateInfo, pAllocator)));
  52 }
  53
  54 VKAPI_ATTR VkResult VKAPI_CALL createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
  55 {
  56         DE_UNREF(pAllocator);
  57         VK_NULL_RETURN((*pImage = allocateNonDispHandle<Image, VkImage>(device, pCreateInfo, pAllocator)));
  58 }
  59
  60 VKAPI_ATTR VkResult VKAPI_CALL createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
  61 {
  62         DE_UNREF(pAllocator);
  63         VK_NULL_RETURN((*pView = allocateNonDispHandle<ImageView, VkImageView>(device, pCreateInfo, pAllocator)));
  64 }
  65
  66 VKAPI_ATTR VkResult VKAPI_CALL createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
  67 {
  68         DE_UNREF(pAllocator);
  69         VK_NULL_RETURN((*pShaderModule = allocateNonDispHandle<ShaderModule, VkShaderModule>(device, pCreateInfo, pAllocator)));
  70 }
  71
  72 VKAPI_ATTR VkResult VKAPI_CALL createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
  73 {
  74         DE_UNREF(pAllocator);
  75         VK_NULL_RETURN((*pPipelineCache = allocateNonDispHandle<PipelineCache, VkPipelineCache>(device, pCreateInfo, pAllocator)));
  76 }
  77
  78 VKAPI_ATTR VkResult VKAPI_CALL createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
  79 {
  80         DE_UNREF(pAllocator);
  81         VK_NULL_RETURN((*pPipelineLayout = allocateNonDispHandle<PipelineLayout, VkPipelineLayout>(device, pCreateInfo, pAllocator)));
  82 }
  83
  84 VKAPI_ATTR VkResult VKAPI_CALL createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
  85 {
  86         DE_UNREF(pAllocator);
  87         VK_NULL_RETURN((*pSampler = allocateNonDispHandle<Sampler, VkSampler>(device, pCreateInfo, pAllocator)));
  88 }
  89
  90 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
  91 {
  92         DE_UNREF(pAllocator);
  93         VK_NULL_RETURN((*pSetLayout = allocateNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(device, pCreateInfo, pAllocator)));
  94 }
  95
  96 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
  97 {
  98         DE_UNREF(pAllocator);
  99         VK_NULL_RETURN((*pDescriptorPool = allocateNonDispHandle<DescriptorPool, VkDescriptorPool>(device, pCreateInfo, pAllocator)));
 100 }
 101
 102 VKAPI_ATTR VkResult VKAPI_CALL createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 103 {
 104         DE_UNREF(pAllocator);
 105         VK_NULL_RETURN((*pFramebuffer = allocateNonDispHandle<Framebuffer, VkFramebuffer>(device, pCreateInfo, pAllocator)));
 106 }
 107
 108 VKAPI_ATTR VkResult VKAPI_CALL createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 109 {
 110         DE_UNREF(pAllocator);
 111         VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
 112 }
 113
 114 VKAPI_ATTR VkResult VKAPI_CALL createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
 115 {
 116         DE_UNREF(pAllocator);
 117         VK_NULL_RETURN((*pCommandPool = allocateNonDispHandle<CommandPool, VkCommandPool>(device, pCreateInfo, pAllocator)));
 118 }
 119
 120 VKAPI_ATTR VkResult VKAPI_CALL createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 121 {
 122         DE_UNREF(pAllocator);
 123         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 124 }
 125
 126 VKAPI_ATTR VkResult VKAPI_CALL createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 127 {
 128         DE_UNREF(pAllocator);
 129         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 130 }
 131
 132 VKAPI_ATTR VkResult VKAPI_CALL createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
 133 {
 134         DE_UNREF(pAllocator);
 135         VK_NULL_RETURN((*pSwapchain = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfo, pAllocator)));
 136 }
 137
 138 VKAPI_ATTR VkResult VKAPI_CALL createViSurfaceNN (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 139 {
 140         DE_UNREF(pAllocator);
 141         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 142 }
 143
 144 VKAPI_ATTR VkResult VKAPI_CALL createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 145 {
 146         DE_UNREF(pAllocator);
 147         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 148 }
 149
 150 VKAPI_ATTR VkResult VKAPI_CALL createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 151 {
 152         DE_UNREF(pAllocator);
 153         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 154 }
 155
 156 VKAPI_ATTR VkResult VKAPI_CALL createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 157 {
 158         DE_UNREF(pAllocator);
 159         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 160 }
 161
 162 VKAPI_ATTR VkResult VKAPI_CALL createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 163 {
 164         DE_UNREF(pAllocator);
 165         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 166 }
 167
 168 VKAPI_ATTR VkResult VKAPI_CALL createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 169 {
 170         DE_UNREF(pAllocator);
 171         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 172 }
 173
 174 VKAPI_ATTR VkResult VKAPI_CALL createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 175 {
 176         DE_UNREF(pAllocator);
 177         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 178 }
 179
 180 VKAPI_ATTR VkResult VKAPI_CALL createScreenSurfaceQNX (VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 181 {
 182         DE_UNREF(pAllocator);
 183         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 184 }
 185
 186 VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
 187 {
 188         DE_UNREF(pAllocator);
 189         VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
 190 }
 191
 192 VKAPI_ATTR VkResult VKAPI_CALL createIndirectCommandsLayoutNV (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
 193 {
 194         DE_UNREF(pAllocator);
 195         VK_NULL_RETURN((*pIndirectCommandsLayout = allocateNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(device, pCreateInfo, pAllocator)));
 196 }
 197
 198 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorUpdateTemplate (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 199 {
 200         DE_UNREF(pAllocator);
 201         VK_NULL_RETURN((*pDescriptorUpdateTemplate = allocateNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(device, pCreateInfo, pAllocator)));
 202 }
 203
 204 VKAPI_ATTR VkResult VKAPI_CALL createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 205 {
 206         DE_UNREF(pAllocator);
 207         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 208 }
 209
 210 VKAPI_ATTR VkResult VKAPI_CALL createMacOSSurfaceMVK (VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 211 {
 212         DE_UNREF(pAllocator);
 213         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 214 }
 215
 216 VKAPI_ATTR VkResult VKAPI_CALL createMetalSurfaceEXT (VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 217 {
 218         DE_UNREF(pAllocator);
 219         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 220 }
 221
 222 VKAPI_ATTR VkResult VKAPI_CALL createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
 223 {
 224         DE_UNREF(pAllocator);
 225         VK_NULL_RETURN((*pYcbcrConversion = allocateNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(device, pCreateInfo, pAllocator)));
 226 }
 227
 228 VKAPI_ATTR VkResult VKAPI_CALL createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
 229 {
 230         DE_UNREF(pAllocator);
 231         VK_NULL_RETURN((*pValidationCache = allocateNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(device, pCreateInfo, pAllocator)));
 232 }
 233
 234 VKAPI_ATTR VkResult VKAPI_CALL createDebugUtilsMessengerEXT (VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger)
 235 {
 236         DE_UNREF(pAllocator);
 237         VK_NULL_RETURN((*pMessenger = allocateNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(instance, pCreateInfo, pAllocator)));
 238 }
 239
 240 VKAPI_ATTR VkResult VKAPI_CALL createRenderPass2 (VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 241 {
 242         DE_UNREF(pAllocator);
 243         VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
 244 }
 245
 246 VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureNV (VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure)
 247 {
 248         DE_UNREF(pAllocator);
 249         VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(device, pCreateInfo, pAllocator)));
 250 }
 251
 252 VKAPI_ATTR VkResult VKAPI_CALL createHeadlessSurfaceEXT (VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 253 {
 254         DE_UNREF(pAllocator);
 255         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 256 }
 257
 258 VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureKHR (VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure)
 259 {
 260         DE_UNREF(pAllocator);
 261         VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(device, pCreateInfo, pAllocator)));
 262 }
 263
 264 VKAPI_ATTR VkResult VKAPI_CALL createDeferredOperationKHR (VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation)
 265 {
 266         DE_UNREF(pAllocator);
 267         VK_NULL_RETURN((*pDeferredOperation = allocateNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(device, pAllocator)));
 268 }
 269
 270 VKAPI_ATTR VkResult VKAPI_CALL createPrivateDataSlot (VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
 271 {
 272         DE_UNREF(pAllocator);
 273         VK_NULL_RETURN((*pPrivateDataSlot = allocateNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(device, pCreateInfo, pAllocator)));
 274 }
 275
 276 VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession)
 277 {
 278         DE_UNREF(pAllocator);
 279         VK_NULL_RETURN((*pVideoSession = allocateNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(device, pCreateInfo, pAllocator)));
 280 }
 281
 282 VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters)
 283 {
 284         DE_UNREF(pAllocator);
 285         VK_NULL_RETURN((*pVideoSessionParameters = allocateNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(device, pCreateInfo, pAllocator)));
 286 }
 287
 288 VKAPI_ATTR VkResult VKAPI_CALL createCuModuleNVX (VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule)
 289 {
 290         DE_UNREF(pAllocator);
 291         VK_NULL_RETURN((*pModule = allocateNonDispHandle<CuModuleNVX, VkCuModuleNVX>(device, pCreateInfo, pAllocator)));
 292 }
 293
 294 VKAPI_ATTR VkResult VKAPI_CALL createCuFunctionNVX (VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction)
 295 {
 296         DE_UNREF(pAllocator);
 297         VK_NULL_RETURN((*pFunction = allocateNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(device, pCreateInfo, pAllocator)));
 298 }
 299
 300 VKAPI_ATTR VkResult VKAPI_CALL createBufferCollectionFUCHSIA (VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection)
 301 {
 302         DE_UNREF(pAllocator);
 303         VK_NULL_RETURN((*pCollection = allocateNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(device, pCreateInfo, pAllocator)));
 304 }
 305
 306 VKAPI_ATTR VkResult VKAPI_CALL createMicromapEXT (VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap)
 307 {
 308         DE_UNREF(pAllocator);
 309         VK_NULL_RETURN((*pMicromap = allocateNonDispHandle<MicromapEXT, VkMicromapEXT>(device, pCreateInfo, pAllocator)));
 310 }
 311
 312 VKAPI_ATTR VkResult VKAPI_CALL createOpticalFlowSessionNV (VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession)
 313 {
 314         DE_UNREF(pAllocator);
 315         VK_NULL_RETURN((*pSession = allocateNonDispHandle<OpticalFlowSessionNV, VkOpticalFlowSessionNV>(device, pCreateInfo, pAllocator)));
 316 }
 317
 318 VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 319 {
 320         freeHandle<Instance, VkInstance>(instance, pAllocator);
 321 }
 322
 323 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 324 {
 325         freeHandle<Device, VkDevice>(device, pAllocator);
 326 }
 327
 328 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 329 {
 330         DE_UNREF(device);
 331         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 332 }
 333
 334 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 335 {
 336         DE_UNREF(device);
 337         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 338 }
 339
 340 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 341 {
 342         DE_UNREF(device);
 343         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 344 }
 345
 346 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 347 {
 348         DE_UNREF(device);
 349         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 350 }
 351
 352 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 353 {
 354         DE_UNREF(device);
 355         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 356 }
 357
 358 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 359 {
 360         DE_UNREF(device);
 361         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 362 }
 363
 364 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 365 {
 366         DE_UNREF(device);
 367         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 368 }
 369
 370 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 371 {
 372         DE_UNREF(device);
 373         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 374 }
 375
 376 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 377 {
 378         DE_UNREF(device);
 379         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 380 }
 381
 382 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 383 {
 384         DE_UNREF(device);
 385         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 386 }
 387
 388 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 389 {
 390         DE_UNREF(device);
 391         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 392 }
 393
 394 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 395 {
 396         DE_UNREF(device);
 397         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 398 }
 399
 400 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 401 {
 402         DE_UNREF(device);
 403         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 404 }
 405
 406 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 407 {
 408         DE_UNREF(device);
 409         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 410 }
 411
 412 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 413 {
 414         DE_UNREF(device);
 415         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 416 }
 417
 418 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 419 {
 420         DE_UNREF(device);
 421         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 422 }
 423
 424 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 425 {
 426         DE_UNREF(device);
 427         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 428 }
 429
 430 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 431 {
 432         DE_UNREF(device);
 433         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 434 }
 435
 436 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 437 {
 438         DE_UNREF(device);
 439         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 440 }
 441
 442 VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
 443 {
 444         DE_UNREF(instance);
 445         freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
 446 }
 447
 448 VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
 449 {
 450         DE_UNREF(device);
 451         freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
 452 }
 453
 454 VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
 455 {
 456         DE_UNREF(instance);
 457         freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
 458 }
 459
 460 VKAPI_ATTR void VKAPI_CALL destroyIndirectCommandsLayoutNV (VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
 461 {
 462         DE_UNREF(device);
 463         freeNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(indirectCommandsLayout, pAllocator);
 464 }
 465
 466 VKAPI_ATTR void VKAPI_CALL destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
 467 {
 468         DE_UNREF(device);
 469         freeNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, pAllocator);
 470 }
 471
 472 VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
 473 {
 474         DE_UNREF(device);
 475         freeNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(ycbcrConversion, pAllocator);
 476 }
 477
 478 VKAPI_ATTR void VKAPI_CALL destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
 479 {
 480         DE_UNREF(device);
 481         freeNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(validationCache, pAllocator);
 482 }
 483
 484 VKAPI_ATTR void VKAPI_CALL destroyDebugUtilsMessengerEXT (VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator)
 485 {
 486         DE_UNREF(instance);
 487         freeNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(messenger, pAllocator);
 488 }
 489
 490 VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureKHR (VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator)
 491 {
 492         DE_UNREF(device);
 493         freeNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(accelerationStructure, pAllocator);
 494 }
 495
 496 VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator)
 497 {
 498         DE_UNREF(device);
 499         freeNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(accelerationStructure, pAllocator);
 500 }
 501
 502 VKAPI_ATTR void VKAPI_CALL destroyDeferredOperationKHR (VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator)
 503 {
 504         DE_UNREF(device);
 505         freeNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(operation, pAllocator);
 506 }
 507
 508 VKAPI_ATTR void VKAPI_CALL destroyPrivateDataSlot (VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
 509 {
 510         DE_UNREF(device);
 511         freeNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(privateDataSlot, pAllocator);
 512 }
 513
 514 VKAPI_ATTR void VKAPI_CALL destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
 515 {
 516         DE_UNREF(device);
 517         freeNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(videoSession, pAllocator);
 518 }
 519
 520 VKAPI_ATTR void VKAPI_CALL destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
 521 {
 522         DE_UNREF(device);
 523         freeNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(videoSessionParameters, pAllocator);
 524 }
 525
 526 VKAPI_ATTR void VKAPI_CALL destroyCuModuleNVX (VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator)
 527 {
 528         DE_UNREF(device);
 529         freeNonDispHandle<CuModuleNVX, VkCuModuleNVX>(module, pAllocator);
 530 }
 531
 532 VKAPI_ATTR void VKAPI_CALL destroyCuFunctionNVX (VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator)
 533 {
 534         DE_UNREF(device);
 535         freeNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(function, pAllocator);
 536 }
 537
 538 VKAPI_ATTR void VKAPI_CALL destroyBufferCollectionFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator)
 539 {
 540         DE_UNREF(device);
 541         freeNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(collection, pAllocator);
 542 }
 543
 544 VKAPI_ATTR void VKAPI_CALL destroyMicromapEXT (VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator)
 545 {
 546         DE_UNREF(device);
 547         freeNonDispHandle<MicromapEXT, VkMicromapEXT>(micromap, pAllocator);
 548 }
 549
 550 VKAPI_ATTR void VKAPI_CALL destroyOpticalFlowSessionNV (VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator)
 551 {
 552         DE_UNREF(device);
 553         freeNonDispHandle<OpticalFlowSessionNV, VkOpticalFlowSessionNV>(session, pAllocator);
 554 }
 555
 556 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceVersion (uint32_t* pApiVersion)
 557 {
 558         DE_UNREF(pApiVersion);
 559         return VK_SUCCESS;
 560 }
 561
 562 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (uint32_t* pPropertyCount, VkLayerProperties* pProperties)
 563 {
 564         DE_UNREF(pPropertyCount);
 565         DE_UNREF(pProperties);
 566         return VK_SUCCESS;
 567 }
 568
 569 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
 570 {
 571         DE_UNREF(physicalDevice);
 572         DE_UNREF(pPropertyCount);
 573         DE_UNREF(pProperties);
 574         return VK_SUCCESS;
 575 }
 576
 577 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 578 {
 579         DE_UNREF(queue);
 580         DE_UNREF(submitCount);
 581         DE_UNREF(pSubmits);
 582         DE_UNREF(fence);
 583         return VK_SUCCESS;
 584 }
 585
 586 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 587 {
 588         DE_UNREF(queue);
 589         return VK_SUCCESS;
 590 }
 591
 592 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 593 {
 594         DE_UNREF(device);
 595         return VK_SUCCESS;
 596 }
 597
 598 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 599 {
 600         DE_UNREF(device);
 601         DE_UNREF(memoryRangeCount);
 602         DE_UNREF(pMemoryRanges);
 603         return VK_SUCCESS;
 604 }
 605
 606 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 607 {
 608         DE_UNREF(device);
 609         DE_UNREF(memoryRangeCount);
 610         DE_UNREF(pMemoryRanges);
 611         return VK_SUCCESS;
 612 }
 613
 614 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 615 {
 616         DE_UNREF(device);
 617         DE_UNREF(memory);
 618         DE_UNREF(pCommittedMemoryInBytes);
 619 }
 620
 621 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 622 {
 623         DE_UNREF(device);
 624         DE_UNREF(buffer);
 625         DE_UNREF(memory);
 626         DE_UNREF(memoryOffset);
 627         return VK_SUCCESS;
 628 }
 629
 630 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 631 {
 632         DE_UNREF(device);
 633         DE_UNREF(image);
 634         DE_UNREF(memory);
 635         DE_UNREF(memoryOffset);
 636         return VK_SUCCESS;
 637 }
 638
 639 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 640 {
 641         DE_UNREF(device);
 642         DE_UNREF(image);
 643         DE_UNREF(pSparseMemoryRequirementCount);
 644         DE_UNREF(pSparseMemoryRequirements);
 645 }
 646
 647 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 648 {
 649         DE_UNREF(physicalDevice);
 650         DE_UNREF(format);
 651         DE_UNREF(type);
 652         DE_UNREF(samples);
 653         DE_UNREF(usage);
 654         DE_UNREF(tiling);
 655         DE_UNREF(pPropertyCount);
 656         DE_UNREF(pProperties);
 657 }
 658
 659 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 660 {
 661         DE_UNREF(queue);
 662         DE_UNREF(bindInfoCount);
 663         DE_UNREF(pBindInfo);
 664         DE_UNREF(fence);
 665         return VK_SUCCESS;
 666 }
 667
 668 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences)
 669 {
 670         DE_UNREF(device);
 671         DE_UNREF(fenceCount);
 672         DE_UNREF(pFences);
 673         return VK_SUCCESS;
 674 }
 675
 676 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 677 {
 678         DE_UNREF(device);
 679         DE_UNREF(fence);
 680         return VK_SUCCESS;
 681 }
 682
 683 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
 684 {
 685         DE_UNREF(device);
 686         DE_UNREF(fenceCount);
 687         DE_UNREF(pFences);
 688         DE_UNREF(waitAll);
 689         DE_UNREF(timeout);
 690         return VK_SUCCESS;
 691 }
 692
 693 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 694 {
 695         DE_UNREF(device);
 696         DE_UNREF(event);
 697         return VK_SUCCESS;
 698 }
 699
 700 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 701 {
 702         DE_UNREF(device);
 703         DE_UNREF(event);
 704         return VK_SUCCESS;
 705 }
 706
 707 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 708 {
 709         DE_UNREF(device);
 710         DE_UNREF(event);
 711         return VK_SUCCESS;
 712 }
 713
 714 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 715 {
 716         DE_UNREF(device);
 717         DE_UNREF(queryPool);
 718         DE_UNREF(firstQuery);
 719         DE_UNREF(queryCount);
 720         DE_UNREF(dataSize);
 721         DE_UNREF(pData);
 722         DE_UNREF(stride);
 723         DE_UNREF(flags);
 724         return VK_SUCCESS;
 725 }
 726
 727 VKAPI_ATTR void VKAPI_CALL resetQueryPool (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 728 {
 729         DE_UNREF(device);
 730         DE_UNREF(queryPool);
 731         DE_UNREF(firstQuery);
 732         DE_UNREF(queryCount);
 733 }
 734
 735 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 736 {
 737         DE_UNREF(device);
 738         DE_UNREF(image);
 739         DE_UNREF(pSubresource);
 740         DE_UNREF(pLayout);
 741 }
 742
 743 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
 744 {
 745         DE_UNREF(device);
 746         DE_UNREF(pipelineCache);
 747         DE_UNREF(pDataSize);
 748         DE_UNREF(pData);
 749         return VK_SUCCESS;
 750 }
 751
 752 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
 753 {
 754         DE_UNREF(device);
 755         DE_UNREF(dstCache);
 756         DE_UNREF(srcCacheCount);
 757         DE_UNREF(pSrcCaches);
 758         return VK_SUCCESS;
 759 }
 760
 761 VKAPI_ATTR VkResult VKAPI_CALL getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI (VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
 762 {
 763         DE_UNREF(device);
 764         DE_UNREF(renderpass);
 765         DE_UNREF(pMaxWorkgroupSize);
 766         return VK_SUCCESS;
 767 }
 768
 769 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 770 {
 771         DE_UNREF(device);
 772         DE_UNREF(descriptorWriteCount);
 773         DE_UNREF(pDescriptorWrites);
 774         DE_UNREF(descriptorCopyCount);
 775         DE_UNREF(pDescriptorCopies);
 776 }
 777
 778 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 779 {
 780         DE_UNREF(device);
 781         DE_UNREF(renderPass);
 782         DE_UNREF(pGranularity);
 783 }
 784
 785 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 786 {
 787         DE_UNREF(device);
 788         DE_UNREF(commandPool);
 789         DE_UNREF(flags);
 790         return VK_SUCCESS;
 791 }
 792
 793 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 794 {
 795         DE_UNREF(commandBuffer);
 796         DE_UNREF(pBeginInfo);
 797         return VK_SUCCESS;
 798 }
 799
 800 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 801 {
 802         DE_UNREF(commandBuffer);
 803         return VK_SUCCESS;
 804 }
 805
 806 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 807 {
 808         DE_UNREF(commandBuffer);
 809         DE_UNREF(flags);
 810         return VK_SUCCESS;
 811 }
 812
 813 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 814 {
 815         DE_UNREF(commandBuffer);
 816         DE_UNREF(pipelineBindPoint);
 817         DE_UNREF(pipeline);
 818 }
 819
 820 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
 821 {
 822         DE_UNREF(commandBuffer);
 823         DE_UNREF(firstViewport);
 824         DE_UNREF(viewportCount);
 825         DE_UNREF(pViewports);
 826 }
 827
 828 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
 829 {
 830         DE_UNREF(commandBuffer);
 831         DE_UNREF(firstScissor);
 832         DE_UNREF(scissorCount);
 833         DE_UNREF(pScissors);
 834 }
 835
 836 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 837 {
 838         DE_UNREF(commandBuffer);
 839         DE_UNREF(lineWidth);
 840 }
 841
 842 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 843 {
 844         DE_UNREF(commandBuffer);
 845         DE_UNREF(depthBiasConstantFactor);
 846         DE_UNREF(depthBiasClamp);
 847         DE_UNREF(depthBiasSlopeFactor);
 848 }
 849
 850 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 851 {
 852         DE_UNREF(commandBuffer);
 853         DE_UNREF(blendConstants);
 854 }
 855
 856 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 857 {
 858         DE_UNREF(commandBuffer);
 859         DE_UNREF(minDepthBounds);
 860         DE_UNREF(maxDepthBounds);
 861 }
 862
 863 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 864 {
 865         DE_UNREF(commandBuffer);
 866         DE_UNREF(faceMask);
 867         DE_UNREF(compareMask);
 868 }
 869
 870 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 871 {
 872         DE_UNREF(commandBuffer);
 873         DE_UNREF(faceMask);
 874         DE_UNREF(writeMask);
 875 }
 876
 877 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 878 {
 879         DE_UNREF(commandBuffer);
 880         DE_UNREF(faceMask);
 881         DE_UNREF(reference);
 882 }
 883
 884 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
 885 {
 886         DE_UNREF(commandBuffer);
 887         DE_UNREF(pipelineBindPoint);
 888         DE_UNREF(layout);
 889         DE_UNREF(firstSet);
 890         DE_UNREF(descriptorSetCount);
 891         DE_UNREF(pDescriptorSets);
 892         DE_UNREF(dynamicOffsetCount);
 893         DE_UNREF(pDynamicOffsets);
 894 }
 895
 896 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 897 {
 898         DE_UNREF(commandBuffer);
 899         DE_UNREF(buffer);
 900         DE_UNREF(offset);
 901         DE_UNREF(indexType);
 902 }
 903
 904 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 905 {
 906         DE_UNREF(commandBuffer);
 907         DE_UNREF(firstBinding);
 908         DE_UNREF(bindingCount);
 909         DE_UNREF(pBuffers);
 910         DE_UNREF(pOffsets);
 911 }
 912
 913 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 914 {
 915         DE_UNREF(commandBuffer);
 916         DE_UNREF(vertexCount);
 917         DE_UNREF(instanceCount);
 918         DE_UNREF(firstVertex);
 919         DE_UNREF(firstInstance);
 920 }
 921
 922 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 923 {
 924         DE_UNREF(commandBuffer);
 925         DE_UNREF(indexCount);
 926         DE_UNREF(instanceCount);
 927         DE_UNREF(firstIndex);
 928         DE_UNREF(vertexOffset);
 929         DE_UNREF(firstInstance);
 930 }
 931
 932 VKAPI_ATTR void VKAPI_CALL cmdDrawMultiEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
 933 {
 934         DE_UNREF(commandBuffer);
 935         DE_UNREF(drawCount);
 936         DE_UNREF(pVertexInfo);
 937         DE_UNREF(instanceCount);
 938         DE_UNREF(firstInstance);
 939         DE_UNREF(stride);
 940 }
 941
 942 VKAPI_ATTR void VKAPI_CALL cmdDrawMultiIndexedEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset)
 943 {
 944         DE_UNREF(commandBuffer);
 945         DE_UNREF(drawCount);
 946         DE_UNREF(pIndexInfo);
 947         DE_UNREF(instanceCount);
 948         DE_UNREF(firstInstance);
 949         DE_UNREF(stride);
 950         DE_UNREF(pVertexOffset);
 951 }
 952
 953 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 954 {
 955         DE_UNREF(commandBuffer);
 956         DE_UNREF(buffer);
 957         DE_UNREF(offset);
 958         DE_UNREF(drawCount);
 959         DE_UNREF(stride);
 960 }
 961
 962 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 963 {
 964         DE_UNREF(commandBuffer);
 965         DE_UNREF(buffer);
 966         DE_UNREF(offset);
 967         DE_UNREF(drawCount);
 968         DE_UNREF(stride);
 969 }
 970
 971 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 972 {
 973         DE_UNREF(commandBuffer);
 974         DE_UNREF(groupCountX);
 975         DE_UNREF(groupCountY);
 976         DE_UNREF(groupCountZ);
 977 }
 978
 979 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 980 {
 981         DE_UNREF(commandBuffer);
 982         DE_UNREF(buffer);
 983         DE_UNREF(offset);
 984 }
 985
 986 VKAPI_ATTR void VKAPI_CALL cmdSubpassShadingHUAWEI (VkCommandBuffer commandBuffer)
 987 {
 988         DE_UNREF(commandBuffer);
 989 }
 990
 991 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
 992 {
 993         DE_UNREF(commandBuffer);
 994         DE_UNREF(srcBuffer);
 995         DE_UNREF(dstBuffer);
 996         DE_UNREF(regionCount);
 997         DE_UNREF(pRegions);
 998 }
 999
1000 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
1001 {
1002         DE_UNREF(commandBuffer);
1003         DE_UNREF(srcImage);
1004         DE_UNREF(srcImageLayout);
1005         DE_UNREF(dstImage);
1006         DE_UNREF(dstImageLayout);
1007         DE_UNREF(regionCount);
1008         DE_UNREF(pRegions);
1009 }
1010
1011 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
1012 {
1013         DE_UNREF(commandBuffer);
1014         DE_UNREF(srcImage);
1015         DE_UNREF(srcImageLayout);
1016         DE_UNREF(dstImage);
1017         DE_UNREF(dstImageLayout);
1018         DE_UNREF(regionCount);
1019         DE_UNREF(pRegions);
1020         DE_UNREF(filter);
1021 }
1022
1023 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1024 {
1025         DE_UNREF(commandBuffer);
1026         DE_UNREF(srcBuffer);
1027         DE_UNREF(dstImage);
1028         DE_UNREF(dstImageLayout);
1029         DE_UNREF(regionCount);
1030         DE_UNREF(pRegions);
1031 }
1032
1033 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1034 {
1035         DE_UNREF(commandBuffer);
1036         DE_UNREF(srcImage);
1037         DE_UNREF(srcImageLayout);
1038         DE_UNREF(dstBuffer);
1039         DE_UNREF(regionCount);
1040         DE_UNREF(pRegions);
1041 }
1042
1043 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
1044 {
1045         DE_UNREF(commandBuffer);
1046         DE_UNREF(dstBuffer);
1047         DE_UNREF(dstOffset);
1048         DE_UNREF(dataSize);
1049         DE_UNREF(pData);
1050 }
1051
1052 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
1053 {
1054         DE_UNREF(commandBuffer);
1055         DE_UNREF(dstBuffer);
1056         DE_UNREF(dstOffset);
1057         DE_UNREF(size);
1058         DE_UNREF(data);
1059 }
1060
1061 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1062 {
1063         DE_UNREF(commandBuffer);
1064         DE_UNREF(image);
1065         DE_UNREF(imageLayout);
1066         DE_UNREF(pColor);
1067         DE_UNREF(rangeCount);
1068         DE_UNREF(pRanges);
1069 }
1070
1071 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1072 {
1073         DE_UNREF(commandBuffer);
1074         DE_UNREF(image);
1075         DE_UNREF(imageLayout);
1076         DE_UNREF(pDepthStencil);
1077         DE_UNREF(rangeCount);
1078         DE_UNREF(pRanges);
1079 }
1080
1081 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
1082 {
1083         DE_UNREF(commandBuffer);
1084         DE_UNREF(attachmentCount);
1085         DE_UNREF(pAttachments);
1086         DE_UNREF(rectCount);
1087         DE_UNREF(pRects);
1088 }
1089
1090 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
1091 {
1092         DE_UNREF(commandBuffer);
1093         DE_UNREF(srcImage);
1094         DE_UNREF(srcImageLayout);
1095         DE_UNREF(dstImage);
1096         DE_UNREF(dstImageLayout);
1097         DE_UNREF(regionCount);
1098         DE_UNREF(pRegions);
1099 }
1100
1101 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1102 {
1103         DE_UNREF(commandBuffer);
1104         DE_UNREF(event);
1105         DE_UNREF(stageMask);
1106 }
1107
1108 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1109 {
1110         DE_UNREF(commandBuffer);
1111         DE_UNREF(event);
1112         DE_UNREF(stageMask);
1113 }
1114
1115 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
1116 {
1117         DE_UNREF(commandBuffer);
1118         DE_UNREF(eventCount);
1119         DE_UNREF(pEvents);
1120         DE_UNREF(srcStageMask);
1121         DE_UNREF(dstStageMask);
1122         DE_UNREF(memoryBarrierCount);
1123         DE_UNREF(pMemoryBarriers);
1124         DE_UNREF(bufferMemoryBarrierCount);
1125         DE_UNREF(pBufferMemoryBarriers);
1126         DE_UNREF(imageMemoryBarrierCount);
1127         DE_UNREF(pImageMemoryBarriers);
1128 }
1129
1130 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
1131 {
1132         DE_UNREF(commandBuffer);
1133         DE_UNREF(srcStageMask);
1134         DE_UNREF(dstStageMask);
1135         DE_UNREF(dependencyFlags);
1136         DE_UNREF(memoryBarrierCount);
1137         DE_UNREF(pMemoryBarriers);
1138         DE_UNREF(bufferMemoryBarrierCount);
1139         DE_UNREF(pBufferMemoryBarriers);
1140         DE_UNREF(imageMemoryBarrierCount);
1141         DE_UNREF(pImageMemoryBarriers);
1142 }
1143
1144 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
1145 {
1146         DE_UNREF(commandBuffer);
1147         DE_UNREF(queryPool);
1148         DE_UNREF(query);
1149         DE_UNREF(flags);
1150 }
1151
1152 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
1153 {
1154         DE_UNREF(commandBuffer);
1155         DE_UNREF(queryPool);
1156         DE_UNREF(query);
1157 }
1158
1159 VKAPI_ATTR void VKAPI_CALL cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
1160 {
1161         DE_UNREF(commandBuffer);
1162         DE_UNREF(pConditionalRenderingBegin);
1163 }
1164
1165 VKAPI_ATTR void VKAPI_CALL cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer)
1166 {
1167         DE_UNREF(commandBuffer);
1168 }
1169
1170 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1171 {
1172         DE_UNREF(commandBuffer);
1173         DE_UNREF(queryPool);
1174         DE_UNREF(firstQuery);
1175         DE_UNREF(queryCount);
1176 }
1177
1178 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
1179 {
1180         DE_UNREF(commandBuffer);
1181         DE_UNREF(pipelineStage);
1182         DE_UNREF(queryPool);
1183         DE_UNREF(query);
1184 }
1185
1186 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
1187 {
1188         DE_UNREF(commandBuffer);
1189         DE_UNREF(queryPool);
1190         DE_UNREF(firstQuery);
1191         DE_UNREF(queryCount);
1192         DE_UNREF(dstBuffer);
1193         DE_UNREF(dstOffset);
1194         DE_UNREF(stride);
1195         DE_UNREF(flags);
1196 }
1197
1198 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
1199 {
1200         DE_UNREF(commandBuffer);
1201         DE_UNREF(layout);
1202         DE_UNREF(stageFlags);
1203         DE_UNREF(offset);
1204         DE_UNREF(size);
1205         DE_UNREF(pValues);
1206 }
1207
1208 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
1209 {
1210         DE_UNREF(commandBuffer);
1211         DE_UNREF(pRenderPassBegin);
1212         DE_UNREF(contents);
1213 }
1214
1215 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
1216 {
1217         DE_UNREF(commandBuffer);
1218         DE_UNREF(contents);
1219 }
1220
1221 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
1222 {
1223         DE_UNREF(commandBuffer);
1224 }
1225
1226 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
1227 {
1228         DE_UNREF(commandBuffer);
1229         DE_UNREF(commandBufferCount);
1230         DE_UNREF(pCommandBuffers);
1231 }
1232
1233 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
1234 {
1235         DE_UNREF(physicalDevice);
1236         DE_UNREF(pPropertyCount);
1237         DE_UNREF(pProperties);
1238         return VK_SUCCESS;
1239 }
1240
1241 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
1242 {
1243         DE_UNREF(physicalDevice);
1244         DE_UNREF(pPropertyCount);
1245         DE_UNREF(pProperties);
1246         return VK_SUCCESS;
1247 }
1248
1249 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays)
1250 {
1251         DE_UNREF(physicalDevice);
1252         DE_UNREF(planeIndex);
1253         DE_UNREF(pDisplayCount);
1254         DE_UNREF(pDisplays);
1255         return VK_SUCCESS;
1256 }
1257
1258 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
1259 {
1260         DE_UNREF(physicalDevice);
1261         DE_UNREF(display);
1262         DE_UNREF(pPropertyCount);
1263         DE_UNREF(pProperties);
1264         return VK_SUCCESS;
1265 }
1266
1267 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
1268 {
1269         DE_UNREF(physicalDevice);
1270         DE_UNREF(mode);
1271         DE_UNREF(planeIndex);
1272         DE_UNREF(pCapabilities);
1273         return VK_SUCCESS;
1274 }
1275
1276 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
1277 {
1278         DE_UNREF(physicalDevice);
1279         DE_UNREF(queueFamilyIndex);
1280         DE_UNREF(surface);
1281         DE_UNREF(pSupported);
1282         return VK_SUCCESS;
1283 }
1284
1285 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
1286 {
1287         DE_UNREF(physicalDevice);
1288         DE_UNREF(surface);
1289         DE_UNREF(pSurfaceCapabilities);
1290         return VK_SUCCESS;
1291 }
1292
1293 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
1294 {
1295         DE_UNREF(physicalDevice);
1296         DE_UNREF(surface);
1297         DE_UNREF(pSurfaceFormatCount);
1298         DE_UNREF(pSurfaceFormats);
1299         return VK_SUCCESS;
1300 }
1301
1302 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
1303 {
1304         DE_UNREF(physicalDevice);
1305         DE_UNREF(surface);
1306         DE_UNREF(pPresentModeCount);
1307         DE_UNREF(pPresentModes);
1308         return VK_SUCCESS;
1309 }
1310
1311 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
1312 {
1313         DE_UNREF(device);
1314         DE_UNREF(swapchain);
1315         DE_UNREF(pSwapchainImageCount);
1316         DE_UNREF(pSwapchainImages);
1317         return VK_SUCCESS;
1318 }
1319
1320 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
1321 {
1322         DE_UNREF(device);
1323         DE_UNREF(swapchain);
1324         DE_UNREF(timeout);
1325         DE_UNREF(semaphore);
1326         DE_UNREF(fence);
1327         DE_UNREF(pImageIndex);
1328         return VK_SUCCESS;
1329 }
1330
1331 VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
1332 {
1333         DE_UNREF(queue);
1334         DE_UNREF(pPresentInfo);
1335         return VK_SUCCESS;
1336 }
1337
1338 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::WaylandDisplayPtr display)
1339 {
1340         DE_UNREF(physicalDevice);
1341         DE_UNREF(queueFamilyIndex);
1342         DE_UNREF(display);
1343         return VK_SUCCESS;
1344 }
1345
1346 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
1347 {
1348         DE_UNREF(physicalDevice);
1349         DE_UNREF(queueFamilyIndex);
1350         return VK_SUCCESS;
1351 }
1352
1353 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
1354 {
1355         DE_UNREF(physicalDevice);
1356         DE_UNREF(queueFamilyIndex);
1357         DE_UNREF(dpy);
1358         DE_UNREF(visualID);
1359         return VK_SUCCESS;
1360 }
1361
1362 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
1363 {
1364         DE_UNREF(physicalDevice);
1365         DE_UNREF(queueFamilyIndex);
1366         DE_UNREF(connection);
1367         DE_UNREF(visual_id);
1368         return VK_SUCCESS;
1369 }
1370
1371 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceScreenPresentationSupportQNX (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::QNXScreenWindowPtr window)
1372 {
1373         DE_UNREF(physicalDevice);
1374         DE_UNREF(queueFamilyIndex);
1375         DE_UNREF(window);
1376         return VK_SUCCESS;
1377 }
1378
1379 VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage)
1380 {
1381         DE_UNREF(instance);
1382         DE_UNREF(flags);
1383         DE_UNREF(objectType);
1384         DE_UNREF(object);
1385         DE_UNREF(location);
1386         DE_UNREF(messageCode);
1387         DE_UNREF(pLayerPrefix);
1388         DE_UNREF(pMessage);
1389 }
1390
1391 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
1392 {
1393         DE_UNREF(device);
1394         DE_UNREF(pNameInfo);
1395         return VK_SUCCESS;
1396 }
1397
1398 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
1399 {
1400         DE_UNREF(device);
1401         DE_UNREF(pTagInfo);
1402         return VK_SUCCESS;
1403 }
1404
1405 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1406 {
1407         DE_UNREF(commandBuffer);
1408         DE_UNREF(pMarkerInfo);
1409 }
1410
1411 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
1412 {
1413         DE_UNREF(commandBuffer);
1414 }
1415
1416 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1417 {
1418         DE_UNREF(commandBuffer);
1419         DE_UNREF(pMarkerInfo);
1420 }
1421
1422 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
1423 {
1424         DE_UNREF(physicalDevice);
1425         DE_UNREF(format);
1426         DE_UNREF(type);
1427         DE_UNREF(tiling);
1428         DE_UNREF(usage);
1429         DE_UNREF(flags);
1430         DE_UNREF(externalHandleType);
1431         DE_UNREF(pExternalImageFormatProperties);
1432         return VK_SUCCESS;
1433 }
1434
1435 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
1436 {
1437         DE_UNREF(device);
1438         DE_UNREF(memory);
1439         DE_UNREF(handleType);
1440         DE_UNREF(pHandle);
1441         return VK_SUCCESS;
1442 }
1443
1444 VKAPI_ATTR void VKAPI_CALL cmdExecuteGeneratedCommandsNV (VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
1445 {
1446         DE_UNREF(commandBuffer);
1447         DE_UNREF(isPreprocessed);
1448         DE_UNREF(pGeneratedCommandsInfo);
1449 }
1450
1451 VKAPI_ATTR void VKAPI_CALL cmdPreprocessGeneratedCommandsNV (VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
1452 {
1453         DE_UNREF(commandBuffer);
1454         DE_UNREF(pGeneratedCommandsInfo);
1455 }
1456
1457 VKAPI_ATTR void VKAPI_CALL cmdBindPipelineShaderGroupNV (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
1458 {
1459         DE_UNREF(commandBuffer);
1460         DE_UNREF(pipelineBindPoint);
1461         DE_UNREF(pipeline);
1462         DE_UNREF(groupIndex);
1463 }
1464
1465 VKAPI_ATTR void VKAPI_CALL getGeneratedCommandsMemoryRequirementsNV (VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1466 {
1467         DE_UNREF(device);
1468         DE_UNREF(pInfo);
1469         DE_UNREF(pMemoryRequirements);
1470 }
1471
1472 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
1473 {
1474         DE_UNREF(physicalDevice);
1475         DE_UNREF(pFeatures);
1476 }
1477
1478 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
1479 {
1480         DE_UNREF(physicalDevice);
1481         DE_UNREF(pProperties);
1482 }
1483
1484 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
1485 {
1486         DE_UNREF(physicalDevice);
1487         DE_UNREF(format);
1488         DE_UNREF(pFormatProperties);
1489 }
1490
1491 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
1492 {
1493         DE_UNREF(physicalDevice);
1494         DE_UNREF(pImageFormatInfo);
1495         DE_UNREF(pImageFormatProperties);
1496         return VK_SUCCESS;
1497 }
1498
1499 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
1500 {
1501         DE_UNREF(physicalDevice);
1502         DE_UNREF(pQueueFamilyPropertyCount);
1503         DE_UNREF(pQueueFamilyProperties);
1504 }
1505
1506 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
1507 {
1508         DE_UNREF(physicalDevice);
1509         DE_UNREF(pMemoryProperties);
1510 }
1511
1512 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
1513 {
1514         DE_UNREF(physicalDevice);
1515         DE_UNREF(pFormatInfo);
1516         DE_UNREF(pPropertyCount);
1517         DE_UNREF(pProperties);
1518 }
1519
1520 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
1521 {
1522         DE_UNREF(commandBuffer);
1523         DE_UNREF(pipelineBindPoint);
1524         DE_UNREF(layout);
1525         DE_UNREF(set);
1526         DE_UNREF(descriptorWriteCount);
1527         DE_UNREF(pDescriptorWrites);
1528 }
1529
1530 VKAPI_ATTR void VKAPI_CALL trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
1531 {
1532         DE_UNREF(device);
1533         DE_UNREF(commandPool);
1534         DE_UNREF(flags);
1535 }
1536
1537 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
1538 {
1539         DE_UNREF(physicalDevice);
1540         DE_UNREF(pExternalBufferInfo);
1541         DE_UNREF(pExternalBufferProperties);
1542 }
1543
1544 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1545 {
1546         DE_UNREF(device);
1547         DE_UNREF(pGetWin32HandleInfo);
1548         DE_UNREF(pHandle);
1549         return VK_SUCCESS;
1550 }
1551
1552 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
1553 {
1554         DE_UNREF(device);
1555         DE_UNREF(handleType);
1556         DE_UNREF(handle);
1557         DE_UNREF(pMemoryWin32HandleProperties);
1558         return VK_SUCCESS;
1559 }
1560
1561 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
1562 {
1563         DE_UNREF(device);
1564         DE_UNREF(pGetFdInfo);
1565         DE_UNREF(pFd);
1566         return VK_SUCCESS;
1567 }
1568
1569 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
1570 {
1571         DE_UNREF(device);
1572         DE_UNREF(handleType);
1573         DE_UNREF(fd);
1574         DE_UNREF(pMemoryFdProperties);
1575         return VK_SUCCESS;
1576 }
1577
1578 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
1579 {
1580         DE_UNREF(device);
1581         DE_UNREF(pGetZirconHandleInfo);
1582         DE_UNREF(pZirconHandle);
1583         return VK_SUCCESS;
1584 }
1585
1586 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
1587 {
1588         DE_UNREF(device);
1589         DE_UNREF(handleType);
1590         DE_UNREF(zirconHandle);
1591         DE_UNREF(pMemoryZirconHandleProperties);
1592         return VK_SUCCESS;
1593 }
1594
1595 VKAPI_ATTR VkResult VKAPI_CALL getMemoryRemoteAddressNV (VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
1596 {
1597         DE_UNREF(device);
1598         DE_UNREF(pMemoryGetRemoteAddressInfo);
1599         DE_UNREF(pAddress);
1600         return VK_SUCCESS;
1601 }
1602
1603 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
1604 {
1605         DE_UNREF(physicalDevice);
1606         DE_UNREF(pExternalSemaphoreInfo);
1607         DE_UNREF(pExternalSemaphoreProperties);
1608 }
1609
1610 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1611 {
1612         DE_UNREF(device);
1613         DE_UNREF(pGetWin32HandleInfo);
1614         DE_UNREF(pHandle);
1615         return VK_SUCCESS;
1616 }
1617
1618 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
1619 {
1620         DE_UNREF(device);
1621         DE_UNREF(pImportSemaphoreWin32HandleInfo);
1622         return VK_SUCCESS;
1623 }
1624
1625 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
1626 {
1627         DE_UNREF(device);
1628         DE_UNREF(pGetFdInfo);
1629         DE_UNREF(pFd);
1630         return VK_SUCCESS;
1631 }
1632
1633 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
1634 {
1635         DE_UNREF(device);
1636         DE_UNREF(pImportSemaphoreFdInfo);
1637         return VK_SUCCESS;
1638 }
1639
1640 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
1641 {
1642         DE_UNREF(device);
1643         DE_UNREF(pGetZirconHandleInfo);
1644         DE_UNREF(pZirconHandle);
1645         return VK_SUCCESS;
1646 }
1647
1648 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
1649 {
1650         DE_UNREF(device);
1651         DE_UNREF(pImportSemaphoreZirconHandleInfo);
1652         return VK_SUCCESS;
1653 }
1654
1655 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
1656 {
1657         DE_UNREF(physicalDevice);
1658         DE_UNREF(pExternalFenceInfo);
1659         DE_UNREF(pExternalFenceProperties);
1660 }
1661
1662 VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1663 {
1664         DE_UNREF(device);
1665         DE_UNREF(pGetWin32HandleInfo);
1666         DE_UNREF(pHandle);
1667         return VK_SUCCESS;
1668 }
1669
1670 VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
1671 {
1672         DE_UNREF(device);
1673         DE_UNREF(pImportFenceWin32HandleInfo);
1674         return VK_SUCCESS;
1675 }
1676
1677 VKAPI_ATTR VkResult VKAPI_CALL getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
1678 {
1679         DE_UNREF(device);
1680         DE_UNREF(pGetFdInfo);
1681         DE_UNREF(pFd);
1682         return VK_SUCCESS;
1683 }
1684
1685 VKAPI_ATTR VkResult VKAPI_CALL importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
1686 {
1687         DE_UNREF(device);
1688         DE_UNREF(pImportFenceFdInfo);
1689         return VK_SUCCESS;
1690 }
1691
1692 VKAPI_ATTR VkResult VKAPI_CALL releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
1693 {
1694         DE_UNREF(physicalDevice);
1695         DE_UNREF(display);
1696         return VK_SUCCESS;
1697 }
1698
1699 VKAPI_ATTR VkResult VKAPI_CALL acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display)
1700 {
1701         DE_UNREF(physicalDevice);
1702         DE_UNREF(dpy);
1703         DE_UNREF(display);
1704         return VK_SUCCESS;
1705 }
1706
1707 VKAPI_ATTR VkResult VKAPI_CALL getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay)
1708 {
1709         DE_UNREF(physicalDevice);
1710         DE_UNREF(dpy);
1711         DE_UNREF(rrOutput);
1712         DE_UNREF(pDisplay);
1713         return VK_SUCCESS;
1714 }
1715
1716 VKAPI_ATTR VkResult VKAPI_CALL acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
1717 {
1718         DE_UNREF(physicalDevice);
1719         DE_UNREF(display);
1720         return VK_SUCCESS;
1721 }
1722
1723 VKAPI_ATTR VkResult VKAPI_CALL getWinrtDisplayNV (VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay)
1724 {
1725         DE_UNREF(physicalDevice);
1726         DE_UNREF(deviceRelativeId);
1727         DE_UNREF(pDisplay);
1728         return VK_SUCCESS;
1729 }
1730
1731 VKAPI_ATTR VkResult VKAPI_CALL displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
1732 {
1733         DE_UNREF(device);
1734         DE_UNREF(display);
1735         DE_UNREF(pDisplayPowerInfo);
1736         return VK_SUCCESS;
1737 }
1738
1739 VKAPI_ATTR VkResult VKAPI_CALL registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
1740 {
1741         DE_UNREF(device);
1742         DE_UNREF(pDeviceEventInfo);
1743         DE_UNREF(pAllocator);
1744         DE_UNREF(pFence);
1745         return VK_SUCCESS;
1746 }
1747
1748 VKAPI_ATTR VkResult VKAPI_CALL registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
1749 {
1750         DE_UNREF(device);
1751         DE_UNREF(display);
1752         DE_UNREF(pDisplayEventInfo);
1753         DE_UNREF(pAllocator);
1754         DE_UNREF(pFence);
1755         return VK_SUCCESS;
1756 }
1757
1758 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
1759 {
1760         DE_UNREF(device);
1761         DE_UNREF(swapchain);
1762         DE_UNREF(counter);
1763         DE_UNREF(pCounterValue);
1764         return VK_SUCCESS;
1765 }
1766
1767 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
1768 {
1769         DE_UNREF(physicalDevice);
1770         DE_UNREF(surface);
1771         DE_UNREF(pSurfaceCapabilities);
1772         return VK_SUCCESS;
1773 }
1774
1775 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceGroups (VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
1776 {
1777         DE_UNREF(instance);
1778         DE_UNREF(pPhysicalDeviceGroupCount);
1779         DE_UNREF(pPhysicalDeviceGroupProperties);
1780         return VK_SUCCESS;
1781 }
1782
1783 VKAPI_ATTR void VKAPI_CALL getDeviceGroupPeerMemoryFeatures (VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
1784 {
1785         DE_UNREF(device);
1786         DE_UNREF(heapIndex);
1787         DE_UNREF(localDeviceIndex);
1788         DE_UNREF(remoteDeviceIndex);
1789         DE_UNREF(pPeerMemoryFeatures);
1790 }
1791
1792 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
1793 {
1794         DE_UNREF(device);
1795         DE_UNREF(bindInfoCount);
1796         DE_UNREF(pBindInfos);
1797         return VK_SUCCESS;
1798 }
1799
1800 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1801 {
1802         DE_UNREF(device);
1803         DE_UNREF(bindInfoCount);
1804         DE_UNREF(pBindInfos);
1805         return VK_SUCCESS;
1806 }
1807
1808 VKAPI_ATTR void VKAPI_CALL cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint32_t deviceMask)
1809 {
1810         DE_UNREF(commandBuffer);
1811         DE_UNREF(deviceMask);
1812 }
1813
1814 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
1815 {
1816         DE_UNREF(device);
1817         DE_UNREF(pDeviceGroupPresentCapabilities);
1818         return VK_SUCCESS;
1819 }
1820
1821 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
1822 {
1823         DE_UNREF(device);
1824         DE_UNREF(surface);
1825         DE_UNREF(pModes);
1826         return VK_SUCCESS;
1827 }
1828
1829 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex)
1830 {
1831         DE_UNREF(device);
1832         DE_UNREF(pAcquireInfo);
1833         DE_UNREF(pImageIndex);
1834         return VK_SUCCESS;
1835 }
1836
1837 VKAPI_ATTR void VKAPI_CALL cmdDispatchBase (VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1838 {
1839         DE_UNREF(commandBuffer);
1840         DE_UNREF(baseGroupX);
1841         DE_UNREF(baseGroupY);
1842         DE_UNREF(baseGroupZ);
1843         DE_UNREF(groupCountX);
1844         DE_UNREF(groupCountY);
1845         DE_UNREF(groupCountZ);
1846 }
1847
1848 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDevicePresentRectanglesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects)
1849 {
1850         DE_UNREF(physicalDevice);
1851         DE_UNREF(surface);
1852         DE_UNREF(pRectCount);
1853         DE_UNREF(pRects);
1854         return VK_SUCCESS;
1855 }
1856
1857 VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
1858 {
1859         DE_UNREF(device);
1860         DE_UNREF(descriptorSet);
1861         DE_UNREF(descriptorUpdateTemplate);
1862         DE_UNREF(pData);
1863 }
1864
1865 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
1866 {
1867         DE_UNREF(commandBuffer);
1868         DE_UNREF(descriptorUpdateTemplate);
1869         DE_UNREF(layout);
1870         DE_UNREF(set);
1871         DE_UNREF(pData);
1872 }
1873
1874 VKAPI_ATTR void VKAPI_CALL setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
1875 {
1876         DE_UNREF(device);
1877         DE_UNREF(swapchainCount);
1878         DE_UNREF(pSwapchains);
1879         DE_UNREF(pMetadata);
1880 }
1881
1882 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain)
1883 {
1884         DE_UNREF(device);
1885         DE_UNREF(swapchain);
1886         return VK_SUCCESS;
1887 }
1888
1889 VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
1890 {
1891         DE_UNREF(device);
1892         DE_UNREF(swapchain);
1893         DE_UNREF(pDisplayTimingProperties);
1894         return VK_SUCCESS;
1895 }
1896
1897 VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
1898 {
1899         DE_UNREF(device);
1900         DE_UNREF(swapchain);
1901         DE_UNREF(pPresentationTimingCount);
1902         DE_UNREF(pPresentationTimings);
1903         return VK_SUCCESS;
1904 }
1905
1906 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
1907 {
1908         DE_UNREF(commandBuffer);
1909         DE_UNREF(firstViewport);
1910         DE_UNREF(viewportCount);
1911         DE_UNREF(pViewportWScalings);
1912 }
1913
1914 VKAPI_ATTR void VKAPI_CALL cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
1915 {
1916         DE_UNREF(commandBuffer);
1917         DE_UNREF(firstDiscardRectangle);
1918         DE_UNREF(discardRectangleCount);
1919         DE_UNREF(pDiscardRectangles);
1920 }
1921
1922 VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
1923 {
1924         DE_UNREF(commandBuffer);
1925         DE_UNREF(pSampleLocationsInfo);
1926 }
1927
1928 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
1929 {
1930         DE_UNREF(physicalDevice);
1931         DE_UNREF(samples);
1932         DE_UNREF(pMultisampleProperties);
1933 }
1934
1935 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
1936 {
1937         DE_UNREF(physicalDevice);
1938         DE_UNREF(pSurfaceInfo);
1939         DE_UNREF(pSurfaceCapabilities);
1940         return VK_SUCCESS;
1941 }
1942
1943 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
1944 {
1945         DE_UNREF(physicalDevice);
1946         DE_UNREF(pSurfaceInfo);
1947         DE_UNREF(pSurfaceFormatCount);
1948         DE_UNREF(pSurfaceFormats);
1949         return VK_SUCCESS;
1950 }
1951
1952 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties)
1953 {
1954         DE_UNREF(physicalDevice);
1955         DE_UNREF(pPropertyCount);
1956         DE_UNREF(pProperties);
1957         return VK_SUCCESS;
1958 }
1959
1960 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties)
1961 {
1962         DE_UNREF(physicalDevice);
1963         DE_UNREF(pPropertyCount);
1964         DE_UNREF(pProperties);
1965         return VK_SUCCESS;
1966 }
1967
1968 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties)
1969 {
1970         DE_UNREF(physicalDevice);
1971         DE_UNREF(display);
1972         DE_UNREF(pPropertyCount);
1973         DE_UNREF(pProperties);
1974         return VK_SUCCESS;
1975 }
1976
1977 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities)
1978 {
1979         DE_UNREF(physicalDevice);
1980         DE_UNREF(pDisplayPlaneInfo);
1981         DE_UNREF(pCapabilities);
1982         return VK_SUCCESS;
1983 }
1984
1985 VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1986 {
1987         DE_UNREF(device);
1988         DE_UNREF(pInfo);
1989         DE_UNREF(pMemoryRequirements);
1990 }
1991
1992 VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1993 {
1994         DE_UNREF(device);
1995         DE_UNREF(pInfo);
1996         DE_UNREF(pMemoryRequirements);
1997 }
1998
1999 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2000 {
2001         DE_UNREF(device);
2002         DE_UNREF(pInfo);
2003         DE_UNREF(pSparseMemoryRequirementCount);
2004         DE_UNREF(pSparseMemoryRequirements);
2005 }
2006
2007 VKAPI_ATTR void VKAPI_CALL getDeviceBufferMemoryRequirements (VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2008 {
2009         DE_UNREF(device);
2010         DE_UNREF(pInfo);
2011         DE_UNREF(pMemoryRequirements);
2012 }
2013
2014 VKAPI_ATTR void VKAPI_CALL getDeviceImageMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2015 {
2016         DE_UNREF(device);
2017         DE_UNREF(pInfo);
2018         DE_UNREF(pMemoryRequirements);
2019 }
2020
2021 VKAPI_ATTR void VKAPI_CALL getDeviceImageSparseMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2022 {
2023         DE_UNREF(device);
2024         DE_UNREF(pInfo);
2025         DE_UNREF(pSparseMemoryRequirementCount);
2026         DE_UNREF(pSparseMemoryRequirements);
2027 }
2028
2029 VKAPI_ATTR void VKAPI_CALL getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
2030 {
2031         DE_UNREF(device);
2032         DE_UNREF(pQueueInfo);
2033         DE_UNREF(pQueue);
2034 }
2035
2036 VKAPI_ATTR VkResult VKAPI_CALL getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
2037 {
2038         DE_UNREF(device);
2039         DE_UNREF(validationCache);
2040         DE_UNREF(pDataSize);
2041         DE_UNREF(pData);
2042         return VK_SUCCESS;
2043 }
2044
2045 VKAPI_ATTR VkResult VKAPI_CALL mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
2046 {
2047         DE_UNREF(device);
2048         DE_UNREF(dstCache);
2049         DE_UNREF(srcCacheCount);
2050         DE_UNREF(pSrcCaches);
2051         return VK_SUCCESS;
2052 }
2053
2054 VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
2055 {
2056         DE_UNREF(device);
2057         DE_UNREF(pCreateInfo);
2058         DE_UNREF(pSupport);
2059 }
2060
2061 VKAPI_ATTR VkResult VKAPI_CALL getShaderInfoAMD (VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
2062 {
2063         DE_UNREF(device);
2064         DE_UNREF(pipeline);
2065         DE_UNREF(shaderStage);
2066         DE_UNREF(infoType);
2067         DE_UNREF(pInfoSize);
2068         DE_UNREF(pInfo);
2069         return VK_SUCCESS;
2070 }
2071
2072 VKAPI_ATTR void VKAPI_CALL setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
2073 {
2074         DE_UNREF(device);
2075         DE_UNREF(swapChain);
2076         DE_UNREF(localDimmingEnable);
2077 }
2078
2079 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCalibrateableTimeDomainsEXT (VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
2080 {
2081         DE_UNREF(physicalDevice);
2082         DE_UNREF(pTimeDomainCount);
2083         DE_UNREF(pTimeDomains);
2084         return VK_SUCCESS;
2085 }
2086
2087 VKAPI_ATTR VkResult VKAPI_CALL getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
2088 {
2089         DE_UNREF(device);
2090         DE_UNREF(timestampCount);
2091         DE_UNREF(pTimestampInfos);
2092         DE_UNREF(pTimestamps);
2093         DE_UNREF(pMaxDeviation);
2094         return VK_SUCCESS;
2095 }
2096
2097 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
2098 {
2099         DE_UNREF(device);
2100         DE_UNREF(pNameInfo);
2101         return VK_SUCCESS;
2102 }
2103
2104 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
2105 {
2106         DE_UNREF(device);
2107         DE_UNREF(pTagInfo);
2108         return VK_SUCCESS;
2109 }
2110
2111 VKAPI_ATTR void VKAPI_CALL queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2112 {
2113         DE_UNREF(queue);
2114         DE_UNREF(pLabelInfo);
2115 }
2116
2117 VKAPI_ATTR void VKAPI_CALL queueEndDebugUtilsLabelEXT (VkQueue queue)
2118 {
2119         DE_UNREF(queue);
2120 }
2121
2122 VKAPI_ATTR void VKAPI_CALL queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2123 {
2124         DE_UNREF(queue);
2125         DE_UNREF(pLabelInfo);
2126 }
2127
2128 VKAPI_ATTR void VKAPI_CALL cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2129 {
2130         DE_UNREF(commandBuffer);
2131         DE_UNREF(pLabelInfo);
2132 }
2133
2134 VKAPI_ATTR void VKAPI_CALL cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer)
2135 {
2136         DE_UNREF(commandBuffer);
2137 }
2138
2139 VKAPI_ATTR void VKAPI_CALL cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2140 {
2141         DE_UNREF(commandBuffer);
2142         DE_UNREF(pLabelInfo);
2143 }
2144
2145 VKAPI_ATTR void VKAPI_CALL submitDebugUtilsMessageEXT (VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
2146 {
2147         DE_UNREF(instance);
2148         DE_UNREF(messageSeverity);
2149         DE_UNREF(messageTypes);
2150         DE_UNREF(pCallbackData);
2151 }
2152
2153 VKAPI_ATTR VkResult VKAPI_CALL getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
2154 {
2155         DE_UNREF(device);
2156         DE_UNREF(handleType);
2157         DE_UNREF(pHostPointer);
2158         DE_UNREF(pMemoryHostPointerProperties);
2159         return VK_SUCCESS;
2160 }
2161
2162 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarkerAMD (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2163 {
2164         DE_UNREF(commandBuffer);
2165         DE_UNREF(pipelineStage);
2166         DE_UNREF(dstBuffer);
2167         DE_UNREF(dstOffset);
2168         DE_UNREF(marker);
2169 }
2170
2171 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
2172 {
2173         DE_UNREF(commandBuffer);
2174         DE_UNREF(pRenderPassBegin);
2175         DE_UNREF(pSubpassBeginInfo);
2176 }
2177
2178 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass2 (VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
2179 {
2180         DE_UNREF(commandBuffer);
2181         DE_UNREF(pSubpassBeginInfo);
2182         DE_UNREF(pSubpassEndInfo);
2183 }
2184
2185 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass2 (VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
2186 {
2187         DE_UNREF(commandBuffer);
2188         DE_UNREF(pSubpassEndInfo);
2189 }
2190
2191 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
2192 {
2193         DE_UNREF(device);
2194         DE_UNREF(semaphore);
2195         DE_UNREF(pValue);
2196         return VK_SUCCESS;
2197 }
2198
2199 VKAPI_ATTR VkResult VKAPI_CALL waitSemaphores (VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
2200 {
2201         DE_UNREF(device);
2202         DE_UNREF(pWaitInfo);
2203         DE_UNREF(timeout);
2204         return VK_SUCCESS;
2205 }
2206
2207 VKAPI_ATTR VkResult VKAPI_CALL signalSemaphore (VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
2208 {
2209         DE_UNREF(device);
2210         DE_UNREF(pSignalInfo);
2211         return VK_SUCCESS;
2212 }
2213
2214 VKAPI_ATTR VkResult VKAPI_CALL getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
2215 {
2216         DE_UNREF(device);
2217         DE_UNREF(buffer);
2218         DE_UNREF(pProperties);
2219         return VK_SUCCESS;
2220 }
2221
2222 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2223 {
2224         DE_UNREF(commandBuffer);
2225         DE_UNREF(buffer);
2226         DE_UNREF(offset);
2227         DE_UNREF(countBuffer);
2228         DE_UNREF(countBufferOffset);
2229         DE_UNREF(maxDrawCount);
2230         DE_UNREF(stride);
2231 }
2232
2233 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2234 {
2235         DE_UNREF(commandBuffer);
2236         DE_UNREF(buffer);
2237         DE_UNREF(offset);
2238         DE_UNREF(countBuffer);
2239         DE_UNREF(countBufferOffset);
2240         DE_UNREF(maxDrawCount);
2241         DE_UNREF(stride);
2242 }
2243
2244 VKAPI_ATTR void VKAPI_CALL cmdSetCheckpointNV (VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
2245 {
2246         DE_UNREF(commandBuffer);
2247         DE_UNREF(pCheckpointMarker);
2248 }
2249
2250 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointDataNV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
2251 {
2252         DE_UNREF(queue);
2253         DE_UNREF(pCheckpointDataCount);
2254         DE_UNREF(pCheckpointData);
2255 }
2256
2257 VKAPI_ATTR void VKAPI_CALL cmdBindTransformFeedbackBuffersEXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
2258 {
2259         DE_UNREF(commandBuffer);
2260         DE_UNREF(firstBinding);
2261         DE_UNREF(bindingCount);
2262         DE_UNREF(pBuffers);
2263         DE_UNREF(pOffsets);
2264         DE_UNREF(pSizes);
2265 }
2266
2267 VKAPI_ATTR void VKAPI_CALL cmdBeginTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
2268 {
2269         DE_UNREF(commandBuffer);
2270         DE_UNREF(firstCounterBuffer);
2271         DE_UNREF(counterBufferCount);
2272         DE_UNREF(pCounterBuffers);
2273         DE_UNREF(pCounterBufferOffsets);
2274 }
2275
2276 VKAPI_ATTR void VKAPI_CALL cmdEndTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
2277 {
2278         DE_UNREF(commandBuffer);
2279         DE_UNREF(firstCounterBuffer);
2280         DE_UNREF(counterBufferCount);
2281         DE_UNREF(pCounterBuffers);
2282         DE_UNREF(pCounterBufferOffsets);
2283 }
2284
2285 VKAPI_ATTR void VKAPI_CALL cmdBeginQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
2286 {
2287         DE_UNREF(commandBuffer);
2288         DE_UNREF(queryPool);
2289         DE_UNREF(query);
2290         DE_UNREF(flags);
2291         DE_UNREF(index);
2292 }
2293
2294 VKAPI_ATTR void VKAPI_CALL cmdEndQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
2295 {
2296         DE_UNREF(commandBuffer);
2297         DE_UNREF(queryPool);
2298         DE_UNREF(query);
2299         DE_UNREF(index);
2300 }
2301
2302 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectByteCountEXT (VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
2303 {
2304         DE_UNREF(commandBuffer);
2305         DE_UNREF(instanceCount);
2306         DE_UNREF(firstInstance);
2307         DE_UNREF(counterBuffer);
2308         DE_UNREF(counterBufferOffset);
2309         DE_UNREF(counterOffset);
2310         DE_UNREF(vertexStride);
2311 }
2312
2313 VKAPI_ATTR void VKAPI_CALL cmdSetExclusiveScissorNV (VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
2314 {
2315         DE_UNREF(commandBuffer);
2316         DE_UNREF(firstExclusiveScissor);
2317         DE_UNREF(exclusiveScissorCount);
2318         DE_UNREF(pExclusiveScissors);
2319 }
2320
2321 VKAPI_ATTR void VKAPI_CALL cmdBindShadingRateImageNV (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2322 {
2323         DE_UNREF(commandBuffer);
2324         DE_UNREF(imageView);
2325         DE_UNREF(imageLayout);
2326 }
2327
2328 VKAPI_ATTR void VKAPI_CALL cmdSetViewportShadingRatePaletteNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
2329 {
2330         DE_UNREF(commandBuffer);
2331         DE_UNREF(firstViewport);
2332         DE_UNREF(viewportCount);
2333         DE_UNREF(pShadingRatePalettes);
2334 }
2335
2336 VKAPI_ATTR void VKAPI_CALL cmdSetCoarseSampleOrderNV (VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
2337 {
2338         DE_UNREF(commandBuffer);
2339         DE_UNREF(sampleOrderType);
2340         DE_UNREF(customSampleOrderCount);
2341         DE_UNREF(pCustomSampleOrders);
2342 }
2343
2344 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksNV (VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
2345 {
2346         DE_UNREF(commandBuffer);
2347         DE_UNREF(taskCount);
2348         DE_UNREF(firstTask);
2349 }
2350
2351 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
2352 {
2353         DE_UNREF(commandBuffer);
2354         DE_UNREF(buffer);
2355         DE_UNREF(offset);
2356         DE_UNREF(drawCount);
2357         DE_UNREF(stride);
2358 }
2359
2360 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2361 {
2362         DE_UNREF(commandBuffer);
2363         DE_UNREF(buffer);
2364         DE_UNREF(offset);
2365         DE_UNREF(countBuffer);
2366         DE_UNREF(countBufferOffset);
2367         DE_UNREF(maxDrawCount);
2368         DE_UNREF(stride);
2369 }
2370
2371 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksEXT (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
2372 {
2373         DE_UNREF(commandBuffer);
2374         DE_UNREF(groupCountX);
2375         DE_UNREF(groupCountY);
2376         DE_UNREF(groupCountZ);
2377 }
2378
2379 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectEXT (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
2380 {
2381         DE_UNREF(commandBuffer);
2382         DE_UNREF(buffer);
2383         DE_UNREF(offset);
2384         DE_UNREF(drawCount);
2385         DE_UNREF(stride);
2386 }
2387
2388 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountEXT (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2389 {
2390         DE_UNREF(commandBuffer);
2391         DE_UNREF(buffer);
2392         DE_UNREF(offset);
2393         DE_UNREF(countBuffer);
2394         DE_UNREF(countBufferOffset);
2395         DE_UNREF(maxDrawCount);
2396         DE_UNREF(stride);
2397 }
2398
2399 VKAPI_ATTR VkResult VKAPI_CALL compileDeferredNV (VkDevice device, VkPipeline pipeline, uint32_t shader)
2400 {
2401         DE_UNREF(device);
2402         DE_UNREF(pipeline);
2403         DE_UNREF(shader);
2404         return VK_SUCCESS;
2405 }
2406
2407 VKAPI_ATTR void VKAPI_CALL cmdBindInvocationMaskHUAWEI (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2408 {
2409         DE_UNREF(commandBuffer);
2410         DE_UNREF(imageView);
2411         DE_UNREF(imageLayout);
2412 }
2413
2414 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureMemoryRequirementsNV (VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
2415 {
2416         DE_UNREF(device);
2417         DE_UNREF(pInfo);
2418         DE_UNREF(pMemoryRequirements);
2419 }
2420
2421 VKAPI_ATTR VkResult VKAPI_CALL bindAccelerationStructureMemoryNV (VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
2422 {
2423         DE_UNREF(device);
2424         DE_UNREF(bindInfoCount);
2425         DE_UNREF(pBindInfos);
2426         return VK_SUCCESS;
2427 }
2428
2429 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureNV (VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
2430 {
2431         DE_UNREF(commandBuffer);
2432         DE_UNREF(dst);
2433         DE_UNREF(src);
2434         DE_UNREF(mode);
2435 }
2436
2437 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
2438 {
2439         DE_UNREF(commandBuffer);
2440         DE_UNREF(pInfo);
2441 }
2442
2443 VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo)
2444 {
2445         DE_UNREF(device);
2446         DE_UNREF(deferredOperation);
2447         DE_UNREF(pInfo);
2448         return VK_SUCCESS;
2449 }
2450
2451 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureToMemoryKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2452 {
2453         DE_UNREF(commandBuffer);
2454         DE_UNREF(pInfo);
2455 }
2456
2457 VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureToMemoryKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2458 {
2459         DE_UNREF(device);
2460         DE_UNREF(deferredOperation);
2461         DE_UNREF(pInfo);
2462         return VK_SUCCESS;
2463 }
2464
2465 VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2466 {
2467         DE_UNREF(commandBuffer);
2468         DE_UNREF(pInfo);
2469 }
2470
2471 VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2472 {
2473         DE_UNREF(device);
2474         DE_UNREF(deferredOperation);
2475         DE_UNREF(pInfo);
2476         return VK_SUCCESS;
2477 }
2478
2479 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesKHR (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2480 {
2481         DE_UNREF(commandBuffer);
2482         DE_UNREF(accelerationStructureCount);
2483         DE_UNREF(pAccelerationStructures);
2484         DE_UNREF(queryType);
2485         DE_UNREF(queryPool);
2486         DE_UNREF(firstQuery);
2487 }
2488
2489 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesNV (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2490 {
2491         DE_UNREF(commandBuffer);
2492         DE_UNREF(accelerationStructureCount);
2493         DE_UNREF(pAccelerationStructures);
2494         DE_UNREF(queryType);
2495         DE_UNREF(queryPool);
2496         DE_UNREF(firstQuery);
2497 }
2498
2499 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructureNV (VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
2500 {
2501         DE_UNREF(commandBuffer);
2502         DE_UNREF(pInfo);
2503         DE_UNREF(instanceData);
2504         DE_UNREF(instanceOffset);
2505         DE_UNREF(update);
2506         DE_UNREF(dst);
2507         DE_UNREF(src);
2508         DE_UNREF(scratch);
2509         DE_UNREF(scratchOffset);
2510 }
2511
2512 VKAPI_ATTR VkResult VKAPI_CALL writeAccelerationStructuresPropertiesKHR (VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
2513 {
2514         DE_UNREF(device);
2515         DE_UNREF(accelerationStructureCount);
2516         DE_UNREF(pAccelerationStructures);
2517         DE_UNREF(queryType);
2518         DE_UNREF(dataSize);
2519         DE_UNREF(pData);
2520         DE_UNREF(stride);
2521         return VK_SUCCESS;
2522 }
2523
2524 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
2525 {
2526         DE_UNREF(commandBuffer);
2527         DE_UNREF(pRaygenShaderBindingTable);
2528         DE_UNREF(pMissShaderBindingTable);
2529         DE_UNREF(pHitShaderBindingTable);
2530         DE_UNREF(pCallableShaderBindingTable);
2531         DE_UNREF(width);
2532         DE_UNREF(height);
2533         DE_UNREF(depth);
2534 }
2535
2536 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysNV (VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
2537 {
2538         DE_UNREF(commandBuffer);
2539         DE_UNREF(raygenShaderBindingTableBuffer);
2540         DE_UNREF(raygenShaderBindingOffset);
2541         DE_UNREF(missShaderBindingTableBuffer);
2542         DE_UNREF(missShaderBindingOffset);
2543         DE_UNREF(missShaderBindingStride);
2544         DE_UNREF(hitShaderBindingTableBuffer);
2545         DE_UNREF(hitShaderBindingOffset);
2546         DE_UNREF(hitShaderBindingStride);
2547         DE_UNREF(callableShaderBindingTableBuffer);
2548         DE_UNREF(callableShaderBindingOffset);
2549         DE_UNREF(callableShaderBindingStride);
2550         DE_UNREF(width);
2551         DE_UNREF(height);
2552         DE_UNREF(depth);
2553 }
2554
2555 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2556 {
2557         DE_UNREF(device);
2558         DE_UNREF(pipeline);
2559         DE_UNREF(firstGroup);
2560         DE_UNREF(groupCount);
2561         DE_UNREF(dataSize);
2562         DE_UNREF(pData);
2563         return VK_SUCCESS;
2564 }
2565
2566 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingCaptureReplayShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2567 {
2568         DE_UNREF(device);
2569         DE_UNREF(pipeline);
2570         DE_UNREF(firstGroup);
2571         DE_UNREF(groupCount);
2572         DE_UNREF(dataSize);
2573         DE_UNREF(pData);
2574         return VK_SUCCESS;
2575 }
2576
2577 VKAPI_ATTR VkResult VKAPI_CALL getAccelerationStructureHandleNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
2578 {
2579         DE_UNREF(device);
2580         DE_UNREF(accelerationStructure);
2581         DE_UNREF(dataSize);
2582         DE_UNREF(pData);
2583         return VK_SUCCESS;
2584 }
2585
2586 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCooperativeMatrixPropertiesNV (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties)
2587 {
2588         DE_UNREF(physicalDevice);
2589         DE_UNREF(pPropertyCount);
2590         DE_UNREF(pProperties);
2591         return VK_SUCCESS;
2592 }
2593
2594 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirectKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
2595 {
2596         DE_UNREF(commandBuffer);
2597         DE_UNREF(pRaygenShaderBindingTable);
2598         DE_UNREF(pMissShaderBindingTable);
2599         DE_UNREF(pHitShaderBindingTable);
2600         DE_UNREF(pCallableShaderBindingTable);
2601         DE_UNREF(indirectDeviceAddress);
2602 }
2603
2604 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirect2KHR (VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
2605 {
2606         DE_UNREF(commandBuffer);
2607         DE_UNREF(indirectDeviceAddress);
2608 }
2609
2610 VKAPI_ATTR void VKAPI_CALL getDeviceAccelerationStructureCompatibilityKHR (VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
2611 {
2612         DE_UNREF(device);
2613         DE_UNREF(pVersionInfo);
2614         DE_UNREF(pCompatibility);
2615 }
2616
2617 VKAPI_ATTR VkDeviceSize VKAPI_CALL getRayTracingShaderGroupStackSizeKHR (VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
2618 {
2619         DE_UNREF(device);
2620         DE_UNREF(pipeline);
2621         DE_UNREF(group);
2622         DE_UNREF(groupShader);
2623         return VK_SUCCESS;
2624 }
2625
2626 VKAPI_ATTR void VKAPI_CALL cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
2627 {
2628         DE_UNREF(commandBuffer);
2629         DE_UNREF(pipelineStackSize);
2630 }
2631
2632 VKAPI_ATTR uint32_t VKAPI_CALL getImageViewHandleNVX (VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
2633 {
2634         DE_UNREF(device);
2635         DE_UNREF(pInfo);
2636         return VK_SUCCESS;
2637 }
2638
2639 VKAPI_ATTR VkResult VKAPI_CALL getImageViewAddressNVX (VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
2640 {
2641         DE_UNREF(device);
2642         DE_UNREF(imageView);
2643         DE_UNREF(pProperties);
2644         return VK_SUCCESS;
2645 }
2646
2647 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModes2EXT (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
2648 {
2649         DE_UNREF(physicalDevice);
2650         DE_UNREF(pSurfaceInfo);
2651         DE_UNREF(pPresentModeCount);
2652         DE_UNREF(pPresentModes);
2653         return VK_SUCCESS;
2654 }
2655
2656 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModes2EXT (VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes)
2657 {
2658         DE_UNREF(device);
2659         DE_UNREF(pSurfaceInfo);
2660         DE_UNREF(pModes);
2661         return VK_SUCCESS;
2662 }
2663
2664 VKAPI_ATTR VkResult VKAPI_CALL acquireFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
2665 {
2666         DE_UNREF(device);
2667         DE_UNREF(swapchain);
2668         return VK_SUCCESS;
2669 }
2670
2671 VKAPI_ATTR VkResult VKAPI_CALL releaseFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
2672 {
2673         DE_UNREF(device);
2674         DE_UNREF(swapchain);
2675         return VK_SUCCESS;
2676 }
2677
2678 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
2679 {
2680         DE_UNREF(physicalDevice);
2681         DE_UNREF(queueFamilyIndex);
2682         DE_UNREF(pCounterCount);
2683         DE_UNREF(pCounters);
2684         DE_UNREF(pCounterDescriptions);
2685         return VK_SUCCESS;
2686 }
2687
2688 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses)
2689 {
2690         DE_UNREF(physicalDevice);
2691         DE_UNREF(pPerformanceQueryCreateInfo);
2692         DE_UNREF(pNumPasses);
2693 }
2694
2695 VKAPI_ATTR VkResult VKAPI_CALL acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
2696 {
2697         DE_UNREF(device);
2698         DE_UNREF(pInfo);
2699         return VK_SUCCESS;
2700 }
2701
2702 VKAPI_ATTR void VKAPI_CALL releaseProfilingLockKHR (VkDevice device)
2703 {
2704         DE_UNREF(device);
2705 }
2706
2707 VKAPI_ATTR VkResult VKAPI_CALL getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2708 {
2709         DE_UNREF(device);
2710         DE_UNREF(image);
2711         DE_UNREF(pProperties);
2712         return VK_SUCCESS;
2713 }
2714
2715 VKAPI_ATTR uint64_t VKAPI_CALL getBufferOpaqueCaptureAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
2716 {
2717         DE_UNREF(device);
2718         DE_UNREF(pInfo);
2719         return VK_SUCCESS;
2720 }
2721
2722 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
2723 {
2724         DE_UNREF(device);
2725         DE_UNREF(pInfo);
2726         return VK_SUCCESS;
2727 }
2728
2729 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV (VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations)
2730 {
2731         DE_UNREF(physicalDevice);
2732         DE_UNREF(pCombinationCount);
2733         DE_UNREF(pCombinations);
2734         return VK_SUCCESS;
2735 }
2736
2737 VKAPI_ATTR VkResult VKAPI_CALL initializePerformanceApiINTEL (VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
2738 {
2739         DE_UNREF(device);
2740         DE_UNREF(pInitializeInfo);
2741         return VK_SUCCESS;
2742 }
2743
2744 VKAPI_ATTR void VKAPI_CALL uninitializePerformanceApiINTEL (VkDevice device)
2745 {
2746         DE_UNREF(device);
2747 }
2748
2749 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
2750 {
2751         DE_UNREF(commandBuffer);
2752         DE_UNREF(pMarkerInfo);
2753         return VK_SUCCESS;
2754 }
2755
2756 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceStreamMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
2757 {
2758         DE_UNREF(commandBuffer);
2759         DE_UNREF(pMarkerInfo);
2760         return VK_SUCCESS;
2761 }
2762
2763 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceOverrideINTEL (VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
2764 {
2765         DE_UNREF(commandBuffer);
2766         DE_UNREF(pOverrideInfo);
2767         return VK_SUCCESS;
2768 }
2769
2770 VKAPI_ATTR VkResult VKAPI_CALL acquirePerformanceConfigurationINTEL (VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
2771 {
2772         DE_UNREF(device);
2773         DE_UNREF(pAcquireInfo);
2774         DE_UNREF(pConfiguration);
2775         return VK_SUCCESS;
2776 }
2777
2778 VKAPI_ATTR VkResult VKAPI_CALL releasePerformanceConfigurationINTEL (VkDevice device, VkPerformanceConfigurationINTEL configuration)
2779 {
2780         DE_UNREF(device);
2781         DE_UNREF(configuration);
2782         return VK_SUCCESS;
2783 }
2784
2785 VKAPI_ATTR VkResult VKAPI_CALL queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration)
2786 {
2787         DE_UNREF(queue);
2788         DE_UNREF(configuration);
2789         return VK_SUCCESS;
2790 }
2791
2792 VKAPI_ATTR VkResult VKAPI_CALL getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
2793 {
2794         DE_UNREF(device);
2795         DE_UNREF(parameter);
2796         DE_UNREF(pValue);
2797         return VK_SUCCESS;
2798 }
2799
2800 VKAPI_ATTR uint64_t VKAPI_CALL getDeviceMemoryOpaqueCaptureAddress (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
2801 {
2802         DE_UNREF(device);
2803         DE_UNREF(pInfo);
2804         return VK_SUCCESS;
2805 }
2806
2807 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
2808 {
2809         DE_UNREF(device);
2810         DE_UNREF(pPipelineInfo);
2811         DE_UNREF(pExecutableCount);
2812         DE_UNREF(pProperties);
2813         return VK_SUCCESS;
2814 }
2815
2816 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
2817 {
2818         DE_UNREF(device);
2819         DE_UNREF(pExecutableInfo);
2820         DE_UNREF(pStatisticCount);
2821         DE_UNREF(pStatistics);
2822         return VK_SUCCESS;
2823 }
2824
2825 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
2826 {
2827         DE_UNREF(device);
2828         DE_UNREF(pExecutableInfo);
2829         DE_UNREF(pInternalRepresentationCount);
2830         DE_UNREF(pInternalRepresentations);
2831         return VK_SUCCESS;
2832 }
2833
2834 VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
2835 {
2836         DE_UNREF(commandBuffer);
2837         DE_UNREF(lineStippleFactor);
2838         DE_UNREF(lineStipplePattern);
2839 }
2840
2841 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceToolProperties (VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
2842 {
2843         DE_UNREF(physicalDevice);
2844         DE_UNREF(pToolCount);
2845         DE_UNREF(pToolProperties);
2846         return VK_SUCCESS;
2847 }
2848
2849 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2850 {
2851         DE_UNREF(commandBuffer);
2852         DE_UNREF(infoCount);
2853         DE_UNREF(pInfos);
2854         DE_UNREF(ppBuildRangeInfos);
2855 }
2856
2857 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresIndirectKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts)
2858 {
2859         DE_UNREF(commandBuffer);
2860         DE_UNREF(infoCount);
2861         DE_UNREF(pInfos);
2862         DE_UNREF(pIndirectDeviceAddresses);
2863         DE_UNREF(pIndirectStrides);
2864         DE_UNREF(ppMaxPrimitiveCounts);
2865 }
2866
2867 VKAPI_ATTR VkResult VKAPI_CALL buildAccelerationStructuresKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2868 {
2869         DE_UNREF(device);
2870         DE_UNREF(deferredOperation);
2871         DE_UNREF(infoCount);
2872         DE_UNREF(pInfos);
2873         DE_UNREF(ppBuildRangeInfos);
2874         return VK_SUCCESS;
2875 }
2876
2877 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getAccelerationStructureDeviceAddressKHR (VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
2878 {
2879         DE_UNREF(device);
2880         DE_UNREF(pInfo);
2881         return VK_SUCCESS;
2882 }
2883
2884 VKAPI_ATTR uint32_t VKAPI_CALL getDeferredOperationMaxConcurrencyKHR (VkDevice device, VkDeferredOperationKHR operation)
2885 {
2886         DE_UNREF(device);
2887         DE_UNREF(operation);
2888         return VK_SUCCESS;
2889 }
2890
2891 VKAPI_ATTR VkResult VKAPI_CALL getDeferredOperationResultKHR (VkDevice device, VkDeferredOperationKHR operation)
2892 {
2893         DE_UNREF(device);
2894         DE_UNREF(operation);
2895         return VK_SUCCESS;
2896 }
2897
2898 VKAPI_ATTR VkResult VKAPI_CALL deferredOperationJoinKHR (VkDevice device, VkDeferredOperationKHR operation)
2899 {
2900         DE_UNREF(device);
2901         DE_UNREF(operation);
2902         return VK_SUCCESS;
2903 }
2904
2905 VKAPI_ATTR void VKAPI_CALL cmdSetCullMode (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
2906 {
2907         DE_UNREF(commandBuffer);
2908         DE_UNREF(cullMode);
2909 }
2910
2911 VKAPI_ATTR void VKAPI_CALL cmdSetFrontFace (VkCommandBuffer commandBuffer, VkFrontFace frontFace)
2912 {
2913         DE_UNREF(commandBuffer);
2914         DE_UNREF(frontFace);
2915 }
2916
2917 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveTopology (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
2918 {
2919         DE_UNREF(commandBuffer);
2920         DE_UNREF(primitiveTopology);
2921 }
2922
2923 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWithCount (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
2924 {
2925         DE_UNREF(commandBuffer);
2926         DE_UNREF(viewportCount);
2927         DE_UNREF(pViewports);
2928 }
2929
2930 VKAPI_ATTR void VKAPI_CALL cmdSetScissorWithCount (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
2931 {
2932         DE_UNREF(commandBuffer);
2933         DE_UNREF(scissorCount);
2934         DE_UNREF(pScissors);
2935 }
2936
2937 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers2 (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
2938 {
2939         DE_UNREF(commandBuffer);
2940         DE_UNREF(firstBinding);
2941         DE_UNREF(bindingCount);
2942         DE_UNREF(pBuffers);
2943         DE_UNREF(pOffsets);
2944         DE_UNREF(pSizes);
2945         DE_UNREF(pStrides);
2946 }
2947
2948 VKAPI_ATTR void VKAPI_CALL cmdSetDepthTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
2949 {
2950         DE_UNREF(commandBuffer);
2951         DE_UNREF(depthTestEnable);
2952 }
2953
2954 VKAPI_ATTR void VKAPI_CALL cmdSetDepthWriteEnable (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
2955 {
2956         DE_UNREF(commandBuffer);
2957         DE_UNREF(depthWriteEnable);
2958 }
2959
2960 VKAPI_ATTR void VKAPI_CALL cmdSetDepthCompareOp (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
2961 {
2962         DE_UNREF(commandBuffer);
2963         DE_UNREF(depthCompareOp);
2964 }
2965
2966 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBoundsTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
2967 {
2968         DE_UNREF(commandBuffer);
2969         DE_UNREF(depthBoundsTestEnable);
2970 }
2971
2972 VKAPI_ATTR void VKAPI_CALL cmdSetStencilTestEnable (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
2973 {
2974         DE_UNREF(commandBuffer);
2975         DE_UNREF(stencilTestEnable);
2976 }
2977
2978 VKAPI_ATTR void VKAPI_CALL cmdSetStencilOp (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
2979 {
2980         DE_UNREF(commandBuffer);
2981         DE_UNREF(faceMask);
2982         DE_UNREF(failOp);
2983         DE_UNREF(passOp);
2984         DE_UNREF(depthFailOp);
2985         DE_UNREF(compareOp);
2986 }
2987
2988 VKAPI_ATTR void VKAPI_CALL cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
2989 {
2990         DE_UNREF(commandBuffer);
2991         DE_UNREF(patchControlPoints);
2992 }
2993
2994 VKAPI_ATTR void VKAPI_CALL cmdSetRasterizerDiscardEnable (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
2995 {
2996         DE_UNREF(commandBuffer);
2997         DE_UNREF(rasterizerDiscardEnable);
2998 }
2999
3000 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBiasEnable (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
3001 {
3002         DE_UNREF(commandBuffer);
3003         DE_UNREF(depthBiasEnable);
3004 }
3005
3006 VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp)
3007 {
3008         DE_UNREF(commandBuffer);
3009         DE_UNREF(logicOp);
3010 }
3011
3012 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveRestartEnable (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
3013 {
3014         DE_UNREF(commandBuffer);
3015         DE_UNREF(primitiveRestartEnable);
3016 }
3017
3018 VKAPI_ATTR void VKAPI_CALL cmdSetTessellationDomainOriginEXT (VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
3019 {
3020         DE_UNREF(commandBuffer);
3021         DE_UNREF(domainOrigin);
3022 }
3023
3024 VKAPI_ATTR void VKAPI_CALL cmdSetDepthClampEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
3025 {
3026         DE_UNREF(commandBuffer);
3027         DE_UNREF(depthClampEnable);
3028 }
3029
3030 VKAPI_ATTR void VKAPI_CALL cmdSetPolygonModeEXT (VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
3031 {
3032         DE_UNREF(commandBuffer);
3033         DE_UNREF(polygonMode);
3034 }
3035
3036 VKAPI_ATTR void VKAPI_CALL cmdSetRasterizationSamplesEXT (VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
3037 {
3038         DE_UNREF(commandBuffer);
3039         DE_UNREF(rasterizationSamples);
3040 }
3041
3042 VKAPI_ATTR void VKAPI_CALL cmdSetSampleMaskEXT (VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask)
3043 {
3044         DE_UNREF(commandBuffer);
3045         DE_UNREF(samples);
3046         DE_UNREF(pSampleMask);
3047 }
3048
3049 VKAPI_ATTR void VKAPI_CALL cmdSetAlphaToCoverageEnableEXT (VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
3050 {
3051         DE_UNREF(commandBuffer);
3052         DE_UNREF(alphaToCoverageEnable);
3053 }
3054
3055 VKAPI_ATTR void VKAPI_CALL cmdSetAlphaToOneEnableEXT (VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
3056 {
3057         DE_UNREF(commandBuffer);
3058         DE_UNREF(alphaToOneEnable);
3059 }
3060
3061 VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEnableEXT (VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
3062 {
3063         DE_UNREF(commandBuffer);
3064         DE_UNREF(logicOpEnable);
3065 }
3066
3067 VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendEnableEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables)
3068 {
3069         DE_UNREF(commandBuffer);
3070         DE_UNREF(firstAttachment);
3071         DE_UNREF(attachmentCount);
3072         DE_UNREF(pColorBlendEnables);
3073 }
3074
3075 VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendEquationEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations)
3076 {
3077         DE_UNREF(commandBuffer);
3078         DE_UNREF(firstAttachment);
3079         DE_UNREF(attachmentCount);
3080         DE_UNREF(pColorBlendEquations);
3081 }
3082
3083 VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteMaskEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks)
3084 {
3085         DE_UNREF(commandBuffer);
3086         DE_UNREF(firstAttachment);
3087         DE_UNREF(attachmentCount);
3088         DE_UNREF(pColorWriteMasks);
3089 }
3090
3091 VKAPI_ATTR void VKAPI_CALL cmdSetRasterizationStreamEXT (VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
3092 {
3093         DE_UNREF(commandBuffer);
3094         DE_UNREF(rasterizationStream);
3095 }
3096
3097 VKAPI_ATTR void VKAPI_CALL cmdSetConservativeRasterizationModeEXT (VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
3098 {
3099         DE_UNREF(commandBuffer);
3100         DE_UNREF(conservativeRasterizationMode);
3101 }
3102
3103 VKAPI_ATTR void VKAPI_CALL cmdSetExtraPrimitiveOverestimationSizeEXT (VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
3104 {
3105         DE_UNREF(commandBuffer);
3106         DE_UNREF(extraPrimitiveOverestimationSize);
3107 }
3108
3109 VKAPI_ATTR void VKAPI_CALL cmdSetDepthClipEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
3110 {
3111         DE_UNREF(commandBuffer);
3112         DE_UNREF(depthClipEnable);
3113 }
3114
3115 VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEnableEXT (VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
3116 {
3117         DE_UNREF(commandBuffer);
3118         DE_UNREF(sampleLocationsEnable);
3119 }
3120
3121 VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendAdvancedEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced)
3122 {
3123         DE_UNREF(commandBuffer);
3124         DE_UNREF(firstAttachment);
3125         DE_UNREF(attachmentCount);
3126         DE_UNREF(pColorBlendAdvanced);
3127 }
3128
3129 VKAPI_ATTR void VKAPI_CALL cmdSetProvokingVertexModeEXT (VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
3130 {
3131         DE_UNREF(commandBuffer);
3132         DE_UNREF(provokingVertexMode);
3133 }
3134
3135 VKAPI_ATTR void VKAPI_CALL cmdSetLineRasterizationModeEXT (VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
3136 {
3137         DE_UNREF(commandBuffer);
3138         DE_UNREF(lineRasterizationMode);
3139 }
3140
3141 VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEnableEXT (VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
3142 {
3143         DE_UNREF(commandBuffer);
3144         DE_UNREF(stippledLineEnable);
3145 }
3146
3147 VKAPI_ATTR void VKAPI_CALL cmdSetDepthClipNegativeOneToOneEXT (VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
3148 {
3149         DE_UNREF(commandBuffer);
3150         DE_UNREF(negativeOneToOne);
3151 }
3152
3153 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingEnableNV (VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
3154 {
3155         DE_UNREF(commandBuffer);
3156         DE_UNREF(viewportWScalingEnable);
3157 }
3158
3159 VKAPI_ATTR void VKAPI_CALL cmdSetViewportSwizzleNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles)
3160 {
3161         DE_UNREF(commandBuffer);
3162         DE_UNREF(firstViewport);
3163         DE_UNREF(viewportCount);
3164         DE_UNREF(pViewportSwizzles);
3165 }
3166
3167 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageToColorEnableNV (VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
3168 {
3169         DE_UNREF(commandBuffer);
3170         DE_UNREF(coverageToColorEnable);
3171 }
3172
3173 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageToColorLocationNV (VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
3174 {
3175         DE_UNREF(commandBuffer);
3176         DE_UNREF(coverageToColorLocation);
3177 }
3178
3179 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationModeNV (VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
3180 {
3181         DE_UNREF(commandBuffer);
3182         DE_UNREF(coverageModulationMode);
3183 }
3184
3185 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationTableEnableNV (VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
3186 {
3187         DE_UNREF(commandBuffer);
3188         DE_UNREF(coverageModulationTableEnable);
3189 }
3190
3191 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationTableNV (VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable)
3192 {
3193         DE_UNREF(commandBuffer);
3194         DE_UNREF(coverageModulationTableCount);
3195         DE_UNREF(pCoverageModulationTable);
3196 }
3197
3198 VKAPI_ATTR void VKAPI_CALL cmdSetShadingRateImageEnableNV (VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
3199 {
3200         DE_UNREF(commandBuffer);
3201         DE_UNREF(shadingRateImageEnable);
3202 }
3203
3204 VKAPI_ATTR void VKAPI_CALL cmdSetCoverageReductionModeNV (VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
3205 {
3206         DE_UNREF(commandBuffer);
3207         DE_UNREF(coverageReductionMode);
3208 }
3209
3210 VKAPI_ATTR void VKAPI_CALL cmdSetRepresentativeFragmentTestEnableNV (VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
3211 {
3212         DE_UNREF(commandBuffer);
3213         DE_UNREF(representativeFragmentTestEnable);
3214 }
3215
3216 VKAPI_ATTR VkResult VKAPI_CALL setPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
3217 {
3218         DE_UNREF(device);
3219         DE_UNREF(objectType);
3220         DE_UNREF(objectHandle);
3221         DE_UNREF(privateDataSlot);
3222         DE_UNREF(data);
3223         return VK_SUCCESS;
3224 }
3225
3226 VKAPI_ATTR void VKAPI_CALL getPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
3227 {
3228         DE_UNREF(device);
3229         DE_UNREF(objectType);
3230         DE_UNREF(objectHandle);
3231         DE_UNREF(privateDataSlot);
3232         DE_UNREF(pData);
3233 }
3234
3235 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer2 (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
3236 {
3237         DE_UNREF(commandBuffer);
3238         DE_UNREF(pCopyBufferInfo);
3239 }
3240
3241 VKAPI_ATTR void VKAPI_CALL cmdCopyImage2 (VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
3242 {
3243         DE_UNREF(commandBuffer);
3244         DE_UNREF(pCopyImageInfo);
3245 }
3246
3247 VKAPI_ATTR void VKAPI_CALL cmdBlitImage2 (VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
3248 {
3249         DE_UNREF(commandBuffer);
3250         DE_UNREF(pBlitImageInfo);
3251 }
3252
3253 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage2 (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
3254 {
3255         DE_UNREF(commandBuffer);
3256         DE_UNREF(pCopyBufferToImageInfo);
3257 }
3258
3259 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer2 (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
3260 {
3261         DE_UNREF(commandBuffer);
3262         DE_UNREF(pCopyImageToBufferInfo);
3263 }
3264
3265 VKAPI_ATTR void VKAPI_CALL cmdResolveImage2 (VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
3266 {
3267         DE_UNREF(commandBuffer);
3268         DE_UNREF(pResolveImageInfo);
3269 }
3270
3271 VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateKHR (VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
3272 {
3273         DE_UNREF(commandBuffer);
3274         DE_UNREF(pFragmentSize);
3275         DE_UNREF(combinerOps);
3276 }
3277
3278 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceFragmentShadingRatesKHR (VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
3279 {
3280         DE_UNREF(physicalDevice);
3281         DE_UNREF(pFragmentShadingRateCount);
3282         DE_UNREF(pFragmentShadingRates);
3283         return VK_SUCCESS;
3284 }
3285
3286 VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateEnumNV (VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
3287 {
3288         DE_UNREF(commandBuffer);
3289         DE_UNREF(shadingRate);
3290         DE_UNREF(combinerOps);
3291 }
3292
3293 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureBuildSizesKHR (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
3294 {
3295         DE_UNREF(device);
3296         DE_UNREF(buildType);
3297         DE_UNREF(pBuildInfo);
3298         DE_UNREF(pMaxPrimitiveCounts);
3299         DE_UNREF(pSizeInfo);
3300 }
3301
3302 VKAPI_ATTR void VKAPI_CALL cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
3303 {
3304         DE_UNREF(commandBuffer);
3305         DE_UNREF(vertexBindingDescriptionCount);
3306         DE_UNREF(pVertexBindingDescriptions);
3307         DE_UNREF(vertexAttributeDescriptionCount);
3308         DE_UNREF(pVertexAttributeDescriptions);
3309 }
3310
3311 VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables)
3312 {
3313         DE_UNREF(commandBuffer);
3314         DE_UNREF(attachmentCount);
3315         DE_UNREF(pColorWriteEnables);
3316 }
3317
3318 VKAPI_ATTR void VKAPI_CALL cmdSetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo)
3319 {
3320         DE_UNREF(commandBuffer);
3321         DE_UNREF(event);
3322         DE_UNREF(pDependencyInfo);
3323 }
3324
3325 VKAPI_ATTR void VKAPI_CALL cmdResetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
3326 {
3327         DE_UNREF(commandBuffer);
3328         DE_UNREF(event);
3329         DE_UNREF(stageMask);
3330 }
3331
3332 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents2 (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos)
3333 {
3334         DE_UNREF(commandBuffer);
3335         DE_UNREF(eventCount);
3336         DE_UNREF(pEvents);
3337         DE_UNREF(pDependencyInfos);
3338 }
3339
3340 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier2 (VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo)
3341 {
3342         DE_UNREF(commandBuffer);
3343         DE_UNREF(pDependencyInfo);
3344 }
3345
3346 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit2 (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
3347 {
3348         DE_UNREF(queue);
3349         DE_UNREF(submitCount);
3350         DE_UNREF(pSubmits);
3351         DE_UNREF(fence);
3352         return VK_SUCCESS;
3353 }
3354
3355 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp2 (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
3356 {
3357         DE_UNREF(commandBuffer);
3358         DE_UNREF(stage);
3359         DE_UNREF(queryPool);
3360         DE_UNREF(query);
3361 }
3362
3363 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
3364 {
3365         DE_UNREF(commandBuffer);
3366         DE_UNREF(stage);
3367         DE_UNREF(dstBuffer);
3368         DE_UNREF(dstOffset);
3369         DE_UNREF(marker);
3370 }
3371
3372 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
3373 {
3374         DE_UNREF(queue);
3375         DE_UNREF(pCheckpointDataCount);
3376         DE_UNREF(pCheckpointData);
3377 }
3378
3379 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities)
3380 {
3381         DE_UNREF(physicalDevice);
3382         DE_UNREF(pVideoProfile);
3383         DE_UNREF(pCapabilities);
3384         return VK_SUCCESS;
3385 }
3386
3387 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties)
3388 {
3389         DE_UNREF(physicalDevice);
3390         DE_UNREF(pVideoFormatInfo);
3391         DE_UNREF(pVideoFormatPropertyCount);
3392         DE_UNREF(pVideoFormatProperties);
3393         return VK_SUCCESS;
3394 }
3395
3396 VKAPI_ATTR VkResult VKAPI_CALL updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
3397 {
3398         DE_UNREF(device);
3399         DE_UNREF(videoSessionParameters);
3400         DE_UNREF(pUpdateInfo);
3401         return VK_SUCCESS;
3402 }
3403
3404 VKAPI_ATTR VkResult VKAPI_CALL getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements)
3405 {
3406         DE_UNREF(device);
3407         DE_UNREF(videoSession);
3408         DE_UNREF(pMemoryRequirementsCount);
3409         DE_UNREF(pMemoryRequirements);
3410         return VK_SUCCESS;
3411 }
3412
3413 VKAPI_ATTR VkResult VKAPI_CALL bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos)
3414 {
3415         DE_UNREF(device);
3416         DE_UNREF(videoSession);
3417         DE_UNREF(bindSessionMemoryInfoCount);
3418         DE_UNREF(pBindSessionMemoryInfos);
3419         return VK_SUCCESS;
3420 }
3421
3422 VKAPI_ATTR void VKAPI_CALL cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo)
3423 {
3424         DE_UNREF(commandBuffer);
3425         DE_UNREF(pDecodeInfo);
3426 }
3427
3428 VKAPI_ATTR void VKAPI_CALL cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
3429 {
3430         DE_UNREF(commandBuffer);
3431         DE_UNREF(pBeginInfo);
3432 }
3433
3434 VKAPI_ATTR void VKAPI_CALL cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
3435 {
3436         DE_UNREF(commandBuffer);
3437         DE_UNREF(pCodingControlInfo);
3438 }
3439
3440 VKAPI_ATTR void VKAPI_CALL cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
3441 {
3442         DE_UNREF(commandBuffer);
3443         DE_UNREF(pEndCodingInfo);
3444 }
3445
3446 VKAPI_ATTR void VKAPI_CALL cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
3447 {
3448         DE_UNREF(commandBuffer);
3449         DE_UNREF(pEncodeInfo);
3450 }
3451
3452 VKAPI_ATTR void VKAPI_CALL cmdCuLaunchKernelNVX (VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
3453 {
3454         DE_UNREF(commandBuffer);
3455         DE_UNREF(pLaunchInfo);
3456 }
3457
3458 VKAPI_ATTR void VKAPI_CALL setDeviceMemoryPriorityEXT (VkDevice device, VkDeviceMemory memory, float priority)
3459 {
3460         DE_UNREF(device);
3461         DE_UNREF(memory);
3462         DE_UNREF(priority);
3463 }
3464
3465 VKAPI_ATTR VkResult VKAPI_CALL acquireDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
3466 {
3467         DE_UNREF(physicalDevice);
3468         DE_UNREF(drmFd);
3469         DE_UNREF(display);
3470         return VK_SUCCESS;
3471 }
3472
3473 VKAPI_ATTR VkResult VKAPI_CALL getDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display)
3474 {
3475         DE_UNREF(physicalDevice);
3476         DE_UNREF(drmFd);
3477         DE_UNREF(connectorId);
3478         DE_UNREF(display);
3479         return VK_SUCCESS;
3480 }
3481
3482 VKAPI_ATTR VkResult VKAPI_CALL waitForPresentKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
3483 {
3484         DE_UNREF(device);
3485         DE_UNREF(swapchain);
3486         DE_UNREF(presentId);
3487         DE_UNREF(timeout);
3488         return VK_SUCCESS;
3489 }
3490
3491 VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionBufferConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
3492 {
3493         DE_UNREF(device);
3494         DE_UNREF(collection);
3495         DE_UNREF(pBufferConstraintsInfo);
3496         return VK_SUCCESS;
3497 }
3498
3499 VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionImageConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
3500 {
3501         DE_UNREF(device);
3502         DE_UNREF(collection);
3503         DE_UNREF(pImageConstraintsInfo);
3504         return VK_SUCCESS;
3505 }
3506
3507 VKAPI_ATTR VkResult VKAPI_CALL getBufferCollectionPropertiesFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties)
3508 {
3509         DE_UNREF(device);
3510         DE_UNREF(collection);
3511         DE_UNREF(pProperties);
3512         return VK_SUCCESS;
3513 }
3514
3515 VKAPI_ATTR void VKAPI_CALL cmdBeginRendering (VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo)
3516 {
3517         DE_UNREF(commandBuffer);
3518         DE_UNREF(pRenderingInfo);
3519 }
3520
3521 VKAPI_ATTR void VKAPI_CALL cmdEndRendering (VkCommandBuffer commandBuffer)
3522 {
3523         DE_UNREF(commandBuffer);
3524 }
3525
3526 VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutHostMappingInfoVALVE (VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping)
3527 {
3528         DE_UNREF(device);
3529         DE_UNREF(pBindingReference);
3530         DE_UNREF(pHostMapping);
3531 }
3532
3533 VKAPI_ATTR void VKAPI_CALL getDescriptorSetHostMappingVALVE (VkDevice device, VkDescriptorSet descriptorSet, void** ppData)
3534 {
3535         DE_UNREF(device);
3536         DE_UNREF(descriptorSet);
3537         DE_UNREF(ppData);
3538 }
3539
3540 VKAPI_ATTR void VKAPI_CALL cmdBuildMicromapsEXT (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
3541 {
3542         DE_UNREF(commandBuffer);
3543         DE_UNREF(infoCount);
3544         DE_UNREF(pInfos);
3545 }
3546
3547 VKAPI_ATTR VkResult VKAPI_CALL buildMicromapsEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
3548 {
3549         DE_UNREF(device);
3550         DE_UNREF(deferredOperation);
3551         DE_UNREF(infoCount);
3552         DE_UNREF(pInfos);
3553         return VK_SUCCESS;
3554 }
3555
3556 VKAPI_ATTR void VKAPI_CALL cmdCopyMicromapEXT (VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo)
3557 {
3558         DE_UNREF(commandBuffer);
3559         DE_UNREF(pInfo);
3560 }
3561
3562 VKAPI_ATTR VkResult VKAPI_CALL copyMicromapEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo)
3563 {
3564         DE_UNREF(device);
3565         DE_UNREF(deferredOperation);
3566         DE_UNREF(pInfo);
3567         return VK_SUCCESS;
3568 }
3569
3570 VKAPI_ATTR void VKAPI_CALL cmdCopyMicromapToMemoryEXT (VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo)
3571 {
3572         DE_UNREF(commandBuffer);
3573         DE_UNREF(pInfo);
3574 }
3575
3576 VKAPI_ATTR VkResult VKAPI_CALL copyMicromapToMemoryEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo)
3577 {
3578         DE_UNREF(device);
3579         DE_UNREF(deferredOperation);
3580         DE_UNREF(pInfo);
3581         return VK_SUCCESS;
3582 }
3583
3584 VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToMicromapEXT (VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo)
3585 {
3586         DE_UNREF(commandBuffer);
3587         DE_UNREF(pInfo);
3588 }
3589
3590 VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToMicromapEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo)
3591 {
3592         DE_UNREF(device);
3593         DE_UNREF(deferredOperation);
3594         DE_UNREF(pInfo);
3595         return VK_SUCCESS;
3596 }
3597
3598 VKAPI_ATTR void VKAPI_CALL cmdWriteMicromapsPropertiesEXT (VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
3599 {
3600         DE_UNREF(commandBuffer);
3601         DE_UNREF(micromapCount);
3602         DE_UNREF(pMicromaps);
3603         DE_UNREF(queryType);
3604         DE_UNREF(queryPool);
3605         DE_UNREF(firstQuery);
3606 }
3607
3608 VKAPI_ATTR VkResult VKAPI_CALL writeMicromapsPropertiesEXT (VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
3609 {
3610         DE_UNREF(device);
3611         DE_UNREF(micromapCount);
3612         DE_UNREF(pMicromaps);
3613         DE_UNREF(queryType);
3614         DE_UNREF(dataSize);
3615         DE_UNREF(pData);
3616         DE_UNREF(stride);
3617         return VK_SUCCESS;
3618 }
3619
3620 VKAPI_ATTR void VKAPI_CALL getDeviceMicromapCompatibilityEXT (VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
3621 {
3622         DE_UNREF(device);
3623         DE_UNREF(pVersionInfo);
3624         DE_UNREF(pCompatibility);
3625 }
3626
3627 VKAPI_ATTR void VKAPI_CALL getMicromapBuildSizesEXT (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo)
3628 {
3629         DE_UNREF(device);
3630         DE_UNREF(buildType);
3631         DE_UNREF(pBuildInfo);
3632         DE_UNREF(pSizeInfo);
3633 }
3634
3635 VKAPI_ATTR void VKAPI_CALL getShaderModuleIdentifierEXT (VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier)
3636 {
3637         DE_UNREF(device);
3638         DE_UNREF(shaderModule);
3639         DE_UNREF(pIdentifier);
3640 }
3641
3642 VKAPI_ATTR void VKAPI_CALL getShaderModuleCreateInfoIdentifierEXT (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier)
3643 {
3644         DE_UNREF(device);
3645         DE_UNREF(pCreateInfo);
3646         DE_UNREF(pIdentifier);
3647 }
3648
3649 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout2EXT (VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout)
3650 {
3651         DE_UNREF(device);
3652         DE_UNREF(image);
3653         DE_UNREF(pSubresource);
3654         DE_UNREF(pLayout);
3655 }
3656
3657 VKAPI_ATTR VkResult VKAPI_CALL getPipelinePropertiesEXT (VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties)
3658 {
3659         DE_UNREF(device);
3660         DE_UNREF(pPipelineInfo);
3661         DE_UNREF(pPipelineProperties);
3662         return VK_SUCCESS;
3663 }
3664
3665 VKAPI_ATTR void VKAPI_CALL exportMetalObjectsEXT (VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo)
3666 {
3667         DE_UNREF(device);
3668         DE_UNREF(pMetalObjectsInfo);
3669 }
3670
3671 VKAPI_ATTR VkResult VKAPI_CALL getFramebufferTilePropertiesQCOM (VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties)
3672 {
3673         DE_UNREF(device);
3674         DE_UNREF(framebuffer);
3675         DE_UNREF(pPropertiesCount);
3676         DE_UNREF(pProperties);
3677         return VK_SUCCESS;
3678 }
3679
3680 VKAPI_ATTR VkResult VKAPI_CALL getDynamicRenderingTilePropertiesQCOM (VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties)
3681 {
3682         DE_UNREF(device);
3683         DE_UNREF(pRenderingInfo);
3684         DE_UNREF(pProperties);
3685         return VK_SUCCESS;
3686 }
3687
3688 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceOpticalFlowImageFormatsNV (VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties)
3689 {
3690         DE_UNREF(physicalDevice);
3691         DE_UNREF(pOpticalFlowImageFormatInfo);
3692         DE_UNREF(pFormatCount);
3693         DE_UNREF(pImageFormatProperties);
3694         return VK_SUCCESS;
3695 }
3696
3697 VKAPI_ATTR VkResult VKAPI_CALL bindOpticalFlowSessionImageNV (VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
3698 {
3699         DE_UNREF(device);
3700         DE_UNREF(session);
3701         DE_UNREF(bindingPoint);
3702         DE_UNREF(view);
3703         DE_UNREF(layout);
3704         return VK_SUCCESS;
3705 }
3706
3707 VKAPI_ATTR void VKAPI_CALL cmdOpticalFlowExecuteNV (VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo)
3708 {
3709         DE_UNREF(commandBuffer);
3710         DE_UNREF(session);
3711         DE_UNREF(pExecuteInfo);
3712 }
3713
3714 VKAPI_ATTR VkResult VKAPI_CALL getDeviceFaultInfoEXT (VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo)
3715 {
3716         DE_UNREF(device);
3717         DE_UNREF(pFaultCounts);
3718         DE_UNREF(pFaultInfo);
3719         return VK_SUCCESS;
3720 }
3721
3722 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
3723 {
3724         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
3725         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
3726         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceVersion,                          enumerateInstanceVersion),
3727         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
3728         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
3729 };
3730
3731 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
3732 {
3733         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                                                   destroyInstance),
3734         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                                                  enumeratePhysicalDevices),
3735         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                                                               getPhysicalDeviceProperties),
3736         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                                                    getPhysicalDeviceQueueFamilyProperties),
3737         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                                                 getPhysicalDeviceMemoryProperties),
3738         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                                                 getPhysicalDeviceFeatures),
3739         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                                                 getPhysicalDeviceFormatProperties),
3740         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                                                    getPhysicalDeviceImageFormatProperties),
3741         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                                                              createDevice),
3742         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                                                    enumerateDeviceLayerProperties),
3743         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                                                enumerateDeviceExtensionProperties),
3744         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,                                              getPhysicalDeviceSparseImageFormatProperties),
3745         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                                                   createAndroidSurfaceKHR),
3746         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                                                             getPhysicalDeviceDisplayPropertiesKHR),
3747         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                                                getPhysicalDeviceDisplayPlanePropertiesKHR),
3748         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                                                               getDisplayPlaneSupportedDisplaysKHR),
3749         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                                                               getDisplayModePropertiesKHR),
3750         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                                                              createDisplayModeKHR),
3751         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                                                    getDisplayPlaneCapabilitiesKHR),
3752         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                                                              createDisplayPlaneSurfaceKHR),
3753         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                                                 destroySurfaceKHR),
3754         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                                                getPhysicalDeviceSurfaceSupportKHR),
3755         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                                                   getPhysicalDeviceSurfaceCapabilitiesKHR),
3756         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                                                getPhysicalDeviceSurfaceFormatsKHR),
3757         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                                                   getPhysicalDeviceSurfacePresentModesKHR),
3758         VK_NULL_FUNC_ENTRY(vkCreateViSurfaceNN,                                                                                                 createViSurfaceNN),
3759         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                                                   createWaylandSurfaceKHR),
3760         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,                                    getPhysicalDeviceWaylandPresentationSupportKHR),
3761         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                                                             createWin32SurfaceKHR),
3762         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,                                              getPhysicalDeviceWin32PresentationSupportKHR),
3763         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                                                              createXlibSurfaceKHR),
3764         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,                                               getPhysicalDeviceXlibPresentationSupportKHR),
3765         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                                                               createXcbSurfaceKHR),
3766         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                                                getPhysicalDeviceXcbPresentationSupportKHR),
3767         VK_NULL_FUNC_ENTRY(vkCreateImagePipeSurfaceFUCHSIA,                                                                             createImagePipeSurfaceFUCHSIA),
3768         VK_NULL_FUNC_ENTRY(vkCreateStreamDescriptorSurfaceGGP,                                                                  createStreamDescriptorSurfaceGGP),
3769         VK_NULL_FUNC_ENTRY(vkCreateScreenSurfaceQNX,                                                                                    createScreenSurfaceQNX),
3770         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceScreenPresentationSupportQNX,                                             getPhysicalDeviceScreenPresentationSupportQNX),
3771         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                                                              createDebugReportCallbackEXT),
3772         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                                                             destroyDebugReportCallbackEXT),
3773         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                                                             debugReportMessageEXT),
3774         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV,                                  getPhysicalDeviceExternalImageFormatPropertiesNV),
3775         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2,                                                                                getPhysicalDeviceFeatures2),
3776         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2,                                                                              getPhysicalDeviceProperties2),
3777         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2,                                                                getPhysicalDeviceFormatProperties2),
3778         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2,                                                   getPhysicalDeviceImageFormatProperties2),
3779         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2,                                                   getPhysicalDeviceQueueFamilyProperties2),
3780         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2,                                                                getPhysicalDeviceMemoryProperties2),
3781         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2,                                             getPhysicalDeviceSparseImageFormatProperties2),
3782         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferProperties,                                                 getPhysicalDeviceExternalBufferProperties),
3783         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties,                                              getPhysicalDeviceExternalSemaphoreProperties),
3784         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFenceProperties,                                                  getPhysicalDeviceExternalFenceProperties),
3785         VK_NULL_FUNC_ENTRY(vkReleaseDisplayEXT,                                                                                                 releaseDisplayEXT),
3786         VK_NULL_FUNC_ENTRY(vkAcquireXlibDisplayEXT,                                                                                             acquireXlibDisplayEXT),
3787         VK_NULL_FUNC_ENTRY(vkGetRandROutputDisplayEXT,                                                                                  getRandROutputDisplayEXT),
3788         VK_NULL_FUNC_ENTRY(vkAcquireWinrtDisplayNV,                                                                                             acquireWinrtDisplayNV),
3789         VK_NULL_FUNC_ENTRY(vkGetWinrtDisplayNV,                                                                                                 getWinrtDisplayNV),
3790         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2EXT,                                                  getPhysicalDeviceSurfaceCapabilities2EXT),
3791         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroups,                                                                             enumeratePhysicalDeviceGroups),
3792         VK_NULL_FUNC_ENTRY(vkGetPhysicalDevicePresentRectanglesKHR,                                                             getPhysicalDevicePresentRectanglesKHR),
3793         VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK,                                                                                               createIOSSurfaceMVK),
3794         VK_NULL_FUNC_ENTRY(vkCreateMacOSSurfaceMVK,                                                                                             createMacOSSurfaceMVK),
3795         VK_NULL_FUNC_ENTRY(vkCreateMetalSurfaceEXT,                                                                                             createMetalSurfaceEXT),
3796         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMultisamplePropertiesEXT,                                                 getPhysicalDeviceMultisamplePropertiesEXT),
3797         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,                                                  getPhysicalDeviceSurfaceCapabilities2KHR),
3798         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,                                                               getPhysicalDeviceSurfaceFormats2KHR),
3799         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR,                                                    getPhysicalDeviceDisplayProperties2KHR),
3800         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR,                                               getPhysicalDeviceDisplayPlaneProperties2KHR),
3801         VK_NULL_FUNC_ENTRY(vkGetDisplayModeProperties2KHR,                                                                              getDisplayModeProperties2KHR),
3802         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilities2KHR,                                                                   getDisplayPlaneCapabilities2KHR),
3803         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,                                              getPhysicalDeviceCalibrateableTimeDomainsEXT),
3804         VK_NULL_FUNC_ENTRY(vkCreateDebugUtilsMessengerEXT,                                                                              createDebugUtilsMessengerEXT),
3805         VK_NULL_FUNC_ENTRY(vkDestroyDebugUtilsMessengerEXT,                                                                             destroyDebugUtilsMessengerEXT),
3806         VK_NULL_FUNC_ENTRY(vkSubmitDebugUtilsMessageEXT,                                                                                submitDebugUtilsMessageEXT),
3807         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,                                    getPhysicalDeviceCooperativeMatrixPropertiesNV),
3808         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModes2EXT,                                                  getPhysicalDeviceSurfacePresentModes2EXT),
3809         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,             enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR),
3810         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,                             getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR),
3811         VK_NULL_FUNC_ENTRY(vkCreateHeadlessSurfaceEXT,                                                                                  createHeadlessSurfaceEXT),
3812         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,   getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV),
3813         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceToolProperties,                                                                   getPhysicalDeviceToolProperties),
3814         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFragmentShadingRatesKHR,                                                  getPhysicalDeviceFragmentShadingRatesKHR),
3815         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoCapabilitiesKHR,                                                             getPhysicalDeviceVideoCapabilitiesKHR),
3816         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoFormatPropertiesKHR,                                                 getPhysicalDeviceVideoFormatPropertiesKHR),
3817         VK_NULL_FUNC_ENTRY(vkAcquireDrmDisplayEXT,                                                                                              acquireDrmDisplayEXT),
3818         VK_NULL_FUNC_ENTRY(vkGetDrmDisplayEXT,                                                                                                  getDrmDisplayEXT),
3819         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceOpticalFlowImageFormatsNV,                                                getPhysicalDeviceOpticalFlowImageFormatsNV),
3820 };
3821
3822 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
3823 {
3824         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                 getDeviceProcAddr),
3825         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                             destroyDevice),
3826         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                                    getDeviceQueue),
3827         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                               queueSubmit),
3828         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                             queueWaitIdle),
3829         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                                    deviceWaitIdle),
3830         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                                                    allocateMemory),
3831         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                                freeMemory),
3832         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                                 mapMemory),
3833         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                               unmapMemory),
3834         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                                   flushMappedMemoryRanges),
3835         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                              invalidateMappedMemoryRanges),
3836         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                                 getDeviceMemoryCommitment),
3837         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                               getBufferMemoryRequirements),
3838         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                                  bindBufferMemory),
3839         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                                getImageMemoryRequirements),
3840         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                                   bindImageMemory),
3841         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                                  getImageSparseMemoryRequirements),
3842         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                                                   queueBindSparse),
3843         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                               createFence),
3844         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                              destroyFence),
3845         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                               resetFences),
3846         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                                    getFenceStatus),
3847         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                             waitForFences),
3848         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                                   createSemaphore),
3849         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                                  destroySemaphore),
3850         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                               createEvent),
3851         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                              destroyEvent),
3852         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                                    getEventStatus),
3853         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                                  setEvent),
3854         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                                resetEvent),
3855         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                                   createQueryPool),
3856         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                                  destroyQueryPool),
3857         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                               getQueryPoolResults),
3858         VK_NULL_FUNC_ENTRY(vkResetQueryPool,                                                                    resetQueryPool),
3859         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                              createBuffer),
3860         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                             destroyBuffer),
3861         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                                  createBufferView),
3862         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                                 destroyBufferView),
3863         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                               createImage),
3864         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                              destroyImage),
3865         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                                 getImageSubresourceLayout),
3866         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                                   createImageView),
3867         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                                  destroyImageView),
3868         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                                createShaderModule),
3869         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                               destroyShaderModule),
3870         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                               createPipelineCache),
3871         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                              destroyPipelineCache),
3872         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                              getPipelineCacheData),
3873         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                               mergePipelineCaches),
3874         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                                   createGraphicsPipelines),
3875         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                                    createComputePipelines),
3876         VK_NULL_FUNC_ENTRY(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,             getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI),
3877         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                                   destroyPipeline),
3878         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                              createPipelineLayout),
3879         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                             destroyPipelineLayout),
3880         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                             createSampler),
3881         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                                    destroySampler),
3882         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                                 createDescriptorSetLayout),
3883         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                                destroyDescriptorSetLayout),
3884         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                              createDescriptorPool),
3885         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                             destroyDescriptorPool),
3886         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                               resetDescriptorPool),
3887         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                                                    allocateDescriptorSets),
3888         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                                freeDescriptorSets),
3889         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                              updateDescriptorSets),
3890         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                                 createFramebuffer),
3891         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                                destroyFramebuffer),
3892         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                                  createRenderPass),
3893         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                                 destroyRenderPass),
3894         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                                  getRenderAreaGranularity),
3895         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                                 createCommandPool),
3896         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                                destroyCommandPool),
3897         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                                  resetCommandPool),
3898         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                                                    allocateCommandBuffers),
3899         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                                                freeCommandBuffers),
3900         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                                beginCommandBuffer),
3901         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                                  endCommandBuffer),
3902         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                                resetCommandBuffer),
3903         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                                   cmdBindPipeline),
3904         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                                                    cmdSetViewport),
3905         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                                             cmdSetScissor),
3906         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                                                   cmdSetLineWidth),
3907         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                                                   cmdSetDepthBias),
3908         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                                              cmdSetBlendConstants),
3909         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                                                 cmdSetDepthBounds),
3910         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                                                  cmdSetStencilCompareMask),
3911         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                                                    cmdSetStencilWriteMask),
3912         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                                                    cmdSetStencilReference),
3913         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                             cmdBindDescriptorSets),
3914         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                                cmdBindIndexBuffer),
3915         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                              cmdBindVertexBuffers),
3916         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                                   cmdDraw),
3917         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                                    cmdDrawIndexed),
3918         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiEXT,                                                                   cmdDrawMultiEXT),
3919         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiIndexedEXT,                                                    cmdDrawMultiIndexedEXT),
3920         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                                   cmdDrawIndirect),
3921         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                                    cmdDrawIndexedIndirect),
3922         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                               cmdDispatch),
3923         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                               cmdDispatchIndirect),
3924         VK_NULL_FUNC_ENTRY(vkCmdSubpassShadingHUAWEI,                                                   cmdSubpassShadingHUAWEI),
3925         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                             cmdCopyBuffer),
3926         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                              cmdCopyImage),
3927         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                              cmdBlitImage),
3928         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                              cmdCopyBufferToImage),
3929         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                              cmdCopyImageToBuffer),
3930         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                                   cmdUpdateBuffer),
3931         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                             cmdFillBuffer),
3932         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                                cmdClearColorImage),
3933         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                                 cmdClearDepthStencilImage),
3934         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                                               cmdClearAttachments),
3935         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                                   cmdResolveImage),
3936         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                               cmdSetEvent),
3937         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                             cmdResetEvent),
3938         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                             cmdWaitEvents),
3939         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                                cmdPipelineBarrier),
3940         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                             cmdBeginQuery),
3941         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                               cmdEndQuery),
3942         VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT,                                   cmdBeginConditionalRenderingEXT),
3943         VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT,                                             cmdEndConditionalRenderingEXT),
3944         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                                 cmdResetQueryPool),
3945         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                                 cmdWriteTimestamp),
3946         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                                   cmdCopyQueryPoolResults),
3947         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                                  cmdPushConstants),
3948         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                                cmdBeginRenderPass),
3949         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                                    cmdNextSubpass),
3950         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                                  cmdEndRenderPass),
3951         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                                cmdExecuteCommands),
3952         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                                                 createSharedSwapchainsKHR),
3953         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                                                createSwapchainKHR),
3954         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                                                               destroySwapchainKHR),
3955         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                                                             getSwapchainImagesKHR),
3956         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                                                               acquireNextImageKHR),
3957         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                                                   queuePresentKHR),
3958         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,                                               debugMarkerSetObjectNameEXT),
3959         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,                                                debugMarkerSetObjectTagEXT),
3960         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,                                                    cmdDebugMarkerBeginEXT),
3961         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,                                                              cmdDebugMarkerEndEXT),
3962         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,                                                   cmdDebugMarkerInsertEXT),
3963         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV,                                                    getMemoryWin32HandleNV),
3964         VK_NULL_FUNC_ENTRY(vkCmdExecuteGeneratedCommandsNV,                                             cmdExecuteGeneratedCommandsNV),
3965         VK_NULL_FUNC_ENTRY(vkCmdPreprocessGeneratedCommandsNV,                                  cmdPreprocessGeneratedCommandsNV),
3966         VK_NULL_FUNC_ENTRY(vkCmdBindPipelineShaderGroupNV,                                              cmdBindPipelineShaderGroupNV),
3967         VK_NULL_FUNC_ENTRY(vkGetGeneratedCommandsMemoryRequirementsNV,                  getGeneratedCommandsMemoryRequirementsNV),
3968         VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNV,                                    createIndirectCommandsLayoutNV),
3969         VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNV,                                   destroyIndirectCommandsLayoutNV),
3970         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,                                                   cmdPushDescriptorSetKHR),
3971         VK_NULL_FUNC_ENTRY(vkTrimCommandPool,                                                                   trimCommandPool),
3972         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,                                                   getMemoryWin32HandleKHR),
3973         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,                                 getMemoryWin32HandlePropertiesKHR),
3974         VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,                                                                    getMemoryFdKHR),
3975         VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,                                                  getMemoryFdPropertiesKHR),
3976         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandleFUCHSIA,                                              getMemoryZirconHandleFUCHSIA),
3977         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA,                    getMemoryZirconHandlePropertiesFUCHSIA),
3978         VK_NULL_FUNC_ENTRY(vkGetMemoryRemoteAddressNV,                                                  getMemoryRemoteAddressNV),
3979         VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,                                                getSemaphoreWin32HandleKHR),
3980         VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,                                             importSemaphoreWin32HandleKHR),
3981         VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,                                                                 getSemaphoreFdKHR),
3982         VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,                                                              importSemaphoreFdKHR),
3983         VK_NULL_FUNC_ENTRY(vkGetSemaphoreZirconHandleFUCHSIA,                                   getSemaphoreZirconHandleFUCHSIA),
3984         VK_NULL_FUNC_ENTRY(vkImportSemaphoreZirconHandleFUCHSIA,                                importSemaphoreZirconHandleFUCHSIA),
3985         VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,                                                    getFenceWin32HandleKHR),
3986         VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,                                                 importFenceWin32HandleKHR),
3987         VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,                                                                             getFenceFdKHR),
3988         VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,                                                                  importFenceFdKHR),
3989         VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT,                                                    displayPowerControlEXT),
3990         VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT,                                                    registerDeviceEventEXT),
3991         VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT,                                                   registerDisplayEventEXT),
3992         VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT,                                                    getSwapchainCounterEXT),
3993         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures,                                  getDeviceGroupPeerMemoryFeatures),
3994         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2,                                                                 bindBufferMemory2),
3995         VK_NULL_FUNC_ENTRY(vkBindImageMemory2,                                                                  bindImageMemory2),
3996         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask,                                                                  cmdSetDeviceMask),
3997         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR,                              getDeviceGroupPresentCapabilitiesKHR),
3998         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR,                              getDeviceGroupSurfacePresentModesKHR),
3999         VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR,                                                              acquireNextImage2KHR),
4000         VK_NULL_FUNC_ENTRY(vkCmdDispatchBase,                                                                   cmdDispatchBase),
4001         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate,                                    createDescriptorUpdateTemplate),
4002         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate,                                   destroyDescriptorUpdateTemplate),
4003         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate,                                   updateDescriptorSetWithTemplate),
4004         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,                               cmdPushDescriptorSetWithTemplateKHR),
4005         VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT,                                                                 setHdrMetadataEXT),
4006         VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,                                                             getSwapchainStatusKHR),
4007         VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,                                             getRefreshCycleDurationGOOGLE),
4008         VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,                                   getPastPresentationTimingGOOGLE),
4009         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV,                                                  cmdSetViewportWScalingNV),
4010         VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT,                                                 cmdSetDiscardRectangleEXT),
4011         VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT,                                                  cmdSetSampleLocationsEXT),
4012         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2,                                              getBufferMemoryRequirements2),
4013         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2,                                               getImageMemoryRequirements2),
4014         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2,                                 getImageSparseMemoryRequirements2),
4015         VK_NULL_FUNC_ENTRY(vkGetDeviceBufferMemoryRequirements,                                 getDeviceBufferMemoryRequirements),
4016         VK_NULL_FUNC_ENTRY(vkGetDeviceImageMemoryRequirements,                                  getDeviceImageMemoryRequirements),
4017         VK_NULL_FUNC_ENTRY(vkGetDeviceImageSparseMemoryRequirements,                    getDeviceImageSparseMemoryRequirements),
4018         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion,                                              createSamplerYcbcrConversion),
4019         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion,                                             destroySamplerYcbcrConversion),
4020         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2,                                                                   getDeviceQueue2),
4021         VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT,                                                  createValidationCacheEXT),
4022         VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT,                                                 destroyValidationCacheEXT),
4023         VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT,                                                 getValidationCacheDataEXT),
4024         VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT,                                                  mergeValidationCachesEXT),
4025         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport,                                             getDescriptorSetLayoutSupport),
4026         VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD,                                                                  getShaderInfoAMD),
4027         VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD,                                                                setLocalDimmingAMD),
4028         VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT,                                                getCalibratedTimestampsEXT),
4029         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT,                                                setDebugUtilsObjectNameEXT),
4030         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT,                                                 setDebugUtilsObjectTagEXT),
4031         VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT,                                              queueBeginDebugUtilsLabelEXT),
4032         VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT,                                                queueEndDebugUtilsLabelEXT),
4033         VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT,                                             queueInsertDebugUtilsLabelEXT),
4034         VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT,                                                cmdBeginDebugUtilsLabelEXT),
4035         VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT,                                                  cmdEndDebugUtilsLabelEXT),
4036         VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT,                                               cmdInsertDebugUtilsLabelEXT),
4037         VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT,                                 getMemoryHostPointerPropertiesEXT),
4038         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD,                                                   cmdWriteBufferMarkerAMD),
4039         VK_NULL_FUNC_ENTRY(vkCreateRenderPass2,                                                                 createRenderPass2),
4040         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2,                                                               cmdBeginRenderPass2),
4041         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2,                                                                   cmdNextSubpass2),
4042         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2,                                                                 cmdEndRenderPass2),
4043         VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValue,                                                  getSemaphoreCounterValue),
4044         VK_NULL_FUNC_ENTRY(vkWaitSemaphores,                                                                    waitSemaphores),
4045         VK_NULL_FUNC_ENTRY(vkSignalSemaphore,                                                                   signalSemaphore),
4046         VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID,                 getAndroidHardwareBufferPropertiesANDROID),
4047         VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID,                             getMemoryAndroidHardwareBufferANDROID),
4048         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCount,                                                              cmdDrawIndirectCount),
4049         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCount,                                               cmdDrawIndexedIndirectCount),
4050         VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV,                                                                cmdSetCheckpointNV),
4051         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV,                                                  getQueueCheckpointDataNV),
4052         VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT,                                cmdBindTransformFeedbackBuffersEXT),
4053         VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT,                                              cmdBeginTransformFeedbackEXT),
4054         VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT,                                                cmdEndTransformFeedbackEXT),
4055         VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT,                                                   cmdBeginQueryIndexedEXT),
4056         VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT,                                                             cmdEndQueryIndexedEXT),
4057         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT,                                               cmdDrawIndirectByteCountEXT),
4058         VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV,                                                  cmdSetExclusiveScissorNV),
4059         VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV,                                                 cmdBindShadingRateImageNV),
4060         VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV,                                cmdSetViewportShadingRatePaletteNV),
4061         VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV,                                                 cmdSetCoarseSampleOrderNV),
4062         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV,                                                                cmdDrawMeshTasksNV),
4063         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV,                                                cmdDrawMeshTasksIndirectNV),
4064         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV,                                   cmdDrawMeshTasksIndirectCountNV),
4065         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksEXT,                                                               cmdDrawMeshTasksEXT),
4066         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectEXT,                                               cmdDrawMeshTasksIndirectEXT),
4067         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountEXT,                                  cmdDrawMeshTasksIndirectCountEXT),
4068         VK_NULL_FUNC_ENTRY(vkCompileDeferredNV,                                                                 compileDeferredNV),
4069         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV,                                             createAccelerationStructureNV),
4070         VK_NULL_FUNC_ENTRY(vkCmdBindInvocationMaskHUAWEI,                                               cmdBindInvocationMaskHUAWEI),
4071         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureKHR,                                   destroyAccelerationStructureKHR),
4072         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV,                                    destroyAccelerationStructureNV),
4073         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV,              getAccelerationStructureMemoryRequirementsNV),
4074         VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV,                                 bindAccelerationStructureMemoryNV),
4075         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV,                                    cmdCopyAccelerationStructureNV),
4076         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureKHR,                                   cmdCopyAccelerationStructureKHR),
4077         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureKHR,                                              copyAccelerationStructureKHR),
4078         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureToMemoryKHR,                   cmdCopyAccelerationStructureToMemoryKHR),
4079         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureToMemoryKHR,                              copyAccelerationStructureToMemoryKHR),
4080         VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToAccelerationStructureKHR,                   cmdCopyMemoryToAccelerationStructureKHR),
4081         VK_NULL_FUNC_ENTRY(vkCopyMemoryToAccelerationStructureKHR,                              copyMemoryToAccelerationStructureKHR),
4082         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesKHR,               cmdWriteAccelerationStructuresPropertiesKHR),
4083         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV,                cmdWriteAccelerationStructuresPropertiesNV),
4084         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV,                                   cmdBuildAccelerationStructureNV),
4085         VK_NULL_FUNC_ENTRY(vkWriteAccelerationStructuresPropertiesKHR,                  writeAccelerationStructuresPropertiesKHR),
4086         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysKHR,                                                                   cmdTraceRaysKHR),
4087         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV,                                                                    cmdTraceRaysNV),
4088         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesKHR,                                getRayTracingShaderGroupHandlesKHR),
4089         VK_NULL_FUNC_ENTRY(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,   getRayTracingCaptureReplayShaderGroupHandlesKHR),
4090         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV,                                  getAccelerationStructureHandleNV),
4091         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV,                                               createRayTracingPipelinesNV),
4092         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesKHR,                                              createRayTracingPipelinesKHR),
4093         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirectKHR,                                                   cmdTraceRaysIndirectKHR),
4094         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirect2KHR,                                                  cmdTraceRaysIndirect2KHR),
4095         VK_NULL_FUNC_ENTRY(vkGetDeviceAccelerationStructureCompatibilityKHR,    getDeviceAccelerationStructureCompatibilityKHR),
4096         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupStackSizeKHR,                              getRayTracingShaderGroupStackSizeKHR),
4097         VK_NULL_FUNC_ENTRY(vkCmdSetRayTracingPipelineStackSizeKHR,                              cmdSetRayTracingPipelineStackSizeKHR),
4098         VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX,                                                             getImageViewHandleNVX),
4099         VK_NULL_FUNC_ENTRY(vkGetImageViewAddressNVX,                                                    getImageViewAddressNVX),
4100         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT,                             getDeviceGroupSurfacePresentModes2EXT),
4101         VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT,                                 acquireFullScreenExclusiveModeEXT),
4102         VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT,                                 releaseFullScreenExclusiveModeEXT),
4103         VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR,                                                   acquireProfilingLockKHR),
4104         VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR,                                                   releaseProfilingLockKHR),
4105         VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT,                    getImageDrmFormatModifierPropertiesEXT),
4106         VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddress,                                             getBufferOpaqueCaptureAddress),
4107         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddress,                                                    getBufferDeviceAddress),
4108         VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL,                                             initializePerformanceApiINTEL),
4109         VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL,                                   uninitializePerformanceApiINTEL),
4110         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL,                                              cmdSetPerformanceMarkerINTEL),
4111         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL,                                cmdSetPerformanceStreamMarkerINTEL),
4112         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL,                                    cmdSetPerformanceOverrideINTEL),
4113         VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL,                              acquirePerformanceConfigurationINTEL),
4114         VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL,                              releasePerformanceConfigurationINTEL),
4115         VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL,                             queueSetPerformanceConfigurationINTEL),
4116         VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL,                                              getPerformanceParameterINTEL),
4117         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddress,                               getDeviceMemoryOpaqueCaptureAddress),
4118         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR,                                getPipelineExecutablePropertiesKHR),
4119         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR,                                getPipelineExecutableStatisticsKHR),
4120         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR,   getPipelineExecutableInternalRepresentationsKHR),
4121         VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT,                                                              cmdSetLineStippleEXT),
4122         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureKHR,                                    createAccelerationStructureKHR),
4123         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresKHR,                                 cmdBuildAccelerationStructuresKHR),
4124         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresIndirectKHR,                 cmdBuildAccelerationStructuresIndirectKHR),
4125         VK_NULL_FUNC_ENTRY(vkBuildAccelerationStructuresKHR,                                    buildAccelerationStructuresKHR),
4126         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureDeviceAddressKHR,                  getAccelerationStructureDeviceAddressKHR),
4127         VK_NULL_FUNC_ENTRY(vkCreateDeferredOperationKHR,                                                createDeferredOperationKHR),
4128         VK_NULL_FUNC_ENTRY(vkDestroyDeferredOperationKHR,                                               destroyDeferredOperationKHR),
4129         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationMaxConcurrencyKHR,                             getDeferredOperationMaxConcurrencyKHR),
4130         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationResultKHR,                                             getDeferredOperationResultKHR),
4131         VK_NULL_FUNC_ENTRY(vkDeferredOperationJoinKHR,                                                  deferredOperationJoinKHR),
4132         VK_NULL_FUNC_ENTRY(vkCmdSetCullMode,                                                                    cmdSetCullMode),
4133         VK_NULL_FUNC_ENTRY(vkCmdSetFrontFace,                                                                   cmdSetFrontFace),
4134         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveTopology,                                                   cmdSetPrimitiveTopology),
4135         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWithCount,                                                   cmdSetViewportWithCount),
4136         VK_NULL_FUNC_ENTRY(vkCmdSetScissorWithCount,                                                    cmdSetScissorWithCount),
4137         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers2,                                                             cmdBindVertexBuffers2),
4138         VK_NULL_FUNC_ENTRY(vkCmdSetDepthTestEnable,                                                             cmdSetDepthTestEnable),
4139         VK_NULL_FUNC_ENTRY(vkCmdSetDepthWriteEnable,                                                    cmdSetDepthWriteEnable),
4140         VK_NULL_FUNC_ENTRY(vkCmdSetDepthCompareOp,                                                              cmdSetDepthCompareOp),
4141         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBoundsTestEnable,                                               cmdSetDepthBoundsTestEnable),
4142         VK_NULL_FUNC_ENTRY(vkCmdSetStencilTestEnable,                                                   cmdSetStencilTestEnable),
4143         VK_NULL_FUNC_ENTRY(vkCmdSetStencilOp,                                                                   cmdSetStencilOp),
4144         VK_NULL_FUNC_ENTRY(vkCmdSetPatchControlPointsEXT,                                               cmdSetPatchControlPointsEXT),
4145         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizerDiscardEnable,                                             cmdSetRasterizerDiscardEnable),
4146         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBiasEnable,                                                             cmdSetDepthBiasEnable),
4147         VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEXT,                                                                  cmdSetLogicOpEXT),
4148         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveRestartEnable,                                              cmdSetPrimitiveRestartEnable),
4149         VK_NULL_FUNC_ENTRY(vkCreatePrivateDataSlot,                                                             createPrivateDataSlot),
4150         VK_NULL_FUNC_ENTRY(vkCmdSetTessellationDomainOriginEXT,                                 cmdSetTessellationDomainOriginEXT),
4151         VK_NULL_FUNC_ENTRY(vkCmdSetDepthClampEnableEXT,                                                 cmdSetDepthClampEnableEXT),
4152         VK_NULL_FUNC_ENTRY(vkCmdSetPolygonModeEXT,                                                              cmdSetPolygonModeEXT),
4153         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizationSamplesEXT,                                             cmdSetRasterizationSamplesEXT),
4154         VK_NULL_FUNC_ENTRY(vkCmdSetSampleMaskEXT,                                                               cmdSetSampleMaskEXT),
4155         VK_NULL_FUNC_ENTRY(vkCmdSetAlphaToCoverageEnableEXT,                                    cmdSetAlphaToCoverageEnableEXT),
4156         VK_NULL_FUNC_ENTRY(vkCmdSetAlphaToOneEnableEXT,                                                 cmdSetAlphaToOneEnableEXT),
4157         VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEnableEXT,                                                    cmdSetLogicOpEnableEXT),
4158         VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendEnableEXT,                                                 cmdSetColorBlendEnableEXT),
4159         VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendEquationEXT,                                               cmdSetColorBlendEquationEXT),
4160         VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteMaskEXT,                                                   cmdSetColorWriteMaskEXT),
4161         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizationStreamEXT,                                              cmdSetRasterizationStreamEXT),
4162         VK_NULL_FUNC_ENTRY(vkCmdSetConservativeRasterizationModeEXT,                    cmdSetConservativeRasterizationModeEXT),
4163         VK_NULL_FUNC_ENTRY(vkCmdSetExtraPrimitiveOverestimationSizeEXT,                 cmdSetExtraPrimitiveOverestimationSizeEXT),
4164         VK_NULL_FUNC_ENTRY(vkCmdSetDepthClipEnableEXT,                                                  cmdSetDepthClipEnableEXT),
4165         VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEnableEXT,                                    cmdSetSampleLocationsEnableEXT),
4166         VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendAdvancedEXT,                                               cmdSetColorBlendAdvancedEXT),
4167         VK_NULL_FUNC_ENTRY(vkCmdSetProvokingVertexModeEXT,                                              cmdSetProvokingVertexModeEXT),
4168         VK_NULL_FUNC_ENTRY(vkCmdSetLineRasterizationModeEXT,                                    cmdSetLineRasterizationModeEXT),
4169         VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEnableEXT,                                                cmdSetLineStippleEnableEXT),
4170         VK_NULL_FUNC_ENTRY(vkCmdSetDepthClipNegativeOneToOneEXT,                                cmdSetDepthClipNegativeOneToOneEXT),
4171         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingEnableNV,                                    cmdSetViewportWScalingEnableNV),
4172         VK_NULL_FUNC_ENTRY(vkCmdSetViewportSwizzleNV,                                                   cmdSetViewportSwizzleNV),
4173         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageToColorEnableNV,                                             cmdSetCoverageToColorEnableNV),
4174         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageToColorLocationNV,                                   cmdSetCoverageToColorLocationNV),
4175         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationModeNV,                                    cmdSetCoverageModulationModeNV),
4176         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationTableEnableNV,                             cmdSetCoverageModulationTableEnableNV),
4177         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationTableNV,                                   cmdSetCoverageModulationTableNV),
4178         VK_NULL_FUNC_ENTRY(vkCmdSetShadingRateImageEnableNV,                                    cmdSetShadingRateImageEnableNV),
4179         VK_NULL_FUNC_ENTRY(vkCmdSetCoverageReductionModeNV,                                             cmdSetCoverageReductionModeNV),
4180         VK_NULL_FUNC_ENTRY(vkCmdSetRepresentativeFragmentTestEnableNV,                  cmdSetRepresentativeFragmentTestEnableNV),
4181         VK_NULL_FUNC_ENTRY(vkDestroyPrivateDataSlot,                                                    destroyPrivateDataSlot),
4182         VK_NULL_FUNC_ENTRY(vkSetPrivateData,                                                                    setPrivateData),
4183         VK_NULL_FUNC_ENTRY(vkGetPrivateData,                                                                    getPrivateData),
4184         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer2,                                                                    cmdCopyBuffer2),
4185         VK_NULL_FUNC_ENTRY(vkCmdCopyImage2,                                                                             cmdCopyImage2),
4186         VK_NULL_FUNC_ENTRY(vkCmdBlitImage2,                                                                             cmdBlitImage2),
4187         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage2,                                                             cmdCopyBufferToImage2),
4188         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer2,                                                             cmdCopyImageToBuffer2),
4189         VK_NULL_FUNC_ENTRY(vkCmdResolveImage2,                                                                  cmdResolveImage2),
4190         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateKHR,                                              cmdSetFragmentShadingRateKHR),
4191         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateEnumNV,                                   cmdSetFragmentShadingRateEnumNV),
4192         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureBuildSizesKHR,                             getAccelerationStructureBuildSizesKHR),
4193         VK_NULL_FUNC_ENTRY(vkCmdSetVertexInputEXT,                                                              cmdSetVertexInputEXT),
4194         VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteEnableEXT,                                                 cmdSetColorWriteEnableEXT),
4195         VK_NULL_FUNC_ENTRY(vkCmdSetEvent2,                                                                              cmdSetEvent2),
4196         VK_NULL_FUNC_ENTRY(vkCmdResetEvent2,                                                                    cmdResetEvent2),
4197         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents2,                                                                    cmdWaitEvents2),
4198         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier2,                                                               cmdPipelineBarrier2),
4199         VK_NULL_FUNC_ENTRY(vkQueueSubmit2,                                                                              queueSubmit2),
4200         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp2,                                                                cmdWriteTimestamp2),
4201         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarker2AMD,                                                  cmdWriteBufferMarker2AMD),
4202         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointData2NV,                                                 getQueueCheckpointData2NV),
4203         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionKHR,                                                             createVideoSessionKHR),
4204         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionKHR,                                                    destroyVideoSessionKHR),
4205         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionParametersKHR,                                   createVideoSessionParametersKHR),
4206         VK_NULL_FUNC_ENTRY(vkUpdateVideoSessionParametersKHR,                                   updateVideoSessionParametersKHR),
4207         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionParametersKHR,                                  destroyVideoSessionParametersKHR),
4208         VK_NULL_FUNC_ENTRY(vkGetVideoSessionMemoryRequirementsKHR,                              getVideoSessionMemoryRequirementsKHR),
4209         VK_NULL_FUNC_ENTRY(vkBindVideoSessionMemoryKHR,                                                 bindVideoSessionMemoryKHR),
4210         VK_NULL_FUNC_ENTRY(vkCmdDecodeVideoKHR,                                                                 cmdDecodeVideoKHR),
4211         VK_NULL_FUNC_ENTRY(vkCmdBeginVideoCodingKHR,                                                    cmdBeginVideoCodingKHR),
4212         VK_NULL_FUNC_ENTRY(vkCmdControlVideoCodingKHR,                                                  cmdControlVideoCodingKHR),
4213         VK_NULL_FUNC_ENTRY(vkCmdEndVideoCodingKHR,                                                              cmdEndVideoCodingKHR),
4214         VK_NULL_FUNC_ENTRY(vkCmdEncodeVideoKHR,                                                                 cmdEncodeVideoKHR),
4215         VK_NULL_FUNC_ENTRY(vkCreateCuModuleNVX,                                                                 createCuModuleNVX),
4216         VK_NULL_FUNC_ENTRY(vkCreateCuFunctionNVX,                                                               createCuFunctionNVX),
4217         VK_NULL_FUNC_ENTRY(vkDestroyCuModuleNVX,                                                                destroyCuModuleNVX),
4218         VK_NULL_FUNC_ENTRY(vkDestroyCuFunctionNVX,                                                              destroyCuFunctionNVX),
4219         VK_NULL_FUNC_ENTRY(vkCmdCuLaunchKernelNVX,                                                              cmdCuLaunchKernelNVX),
4220         VK_NULL_FUNC_ENTRY(vkSetDeviceMemoryPriorityEXT,                                                setDeviceMemoryPriorityEXT),
4221         VK_NULL_FUNC_ENTRY(vkWaitForPresentKHR,                                                                 waitForPresentKHR),
4222         VK_NULL_FUNC_ENTRY(vkCreateBufferCollectionFUCHSIA,                                             createBufferCollectionFUCHSIA),
4223         VK_NULL_FUNC_ENTRY(vkSetBufferCollectionBufferConstraintsFUCHSIA,               setBufferCollectionBufferConstraintsFUCHSIA),
4224         VK_NULL_FUNC_ENTRY(vkSetBufferCollectionImageConstraintsFUCHSIA,                setBufferCollectionImageConstraintsFUCHSIA),
4225         VK_NULL_FUNC_ENTRY(vkDestroyBufferCollectionFUCHSIA,                                    destroyBufferCollectionFUCHSIA),
4226         VK_NULL_FUNC_ENTRY(vkGetBufferCollectionPropertiesFUCHSIA,                              getBufferCollectionPropertiesFUCHSIA),
4227         VK_NULL_FUNC_ENTRY(vkCmdBeginRendering,                                                                 cmdBeginRendering),
4228         VK_NULL_FUNC_ENTRY(vkCmdEndRendering,                                                                   cmdEndRendering),
4229         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutHostMappingInfoVALVE,                getDescriptorSetLayoutHostMappingInfoVALVE),
4230         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetHostMappingVALVE,                                  getDescriptorSetHostMappingVALVE),
4231         VK_NULL_FUNC_ENTRY(vkCreateMicromapEXT,                                                                 createMicromapEXT),
4232         VK_NULL_FUNC_ENTRY(vkCmdBuildMicromapsEXT,                                                              cmdBuildMicromapsEXT),
4233         VK_NULL_FUNC_ENTRY(vkBuildMicromapsEXT,                                                                 buildMicromapsEXT),
4234         VK_NULL_FUNC_ENTRY(vkDestroyMicromapEXT,                                                                destroyMicromapEXT),
4235         VK_NULL_FUNC_ENTRY(vkCmdCopyMicromapEXT,                                                                cmdCopyMicromapEXT),
4236         VK_NULL_FUNC_ENTRY(vkCopyMicromapEXT,                                                                   copyMicromapEXT),
4237         VK_NULL_FUNC_ENTRY(vkCmdCopyMicromapToMemoryEXT,                                                cmdCopyMicromapToMemoryEXT),
4238         VK_NULL_FUNC_ENTRY(vkCopyMicromapToMemoryEXT,                                                   copyMicromapToMemoryEXT),
4239         VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToMicromapEXT,                                                cmdCopyMemoryToMicromapEXT),
4240         VK_NULL_FUNC_ENTRY(vkCopyMemoryToMicromapEXT,                                                   copyMemoryToMicromapEXT),
4241         VK_NULL_FUNC_ENTRY(vkCmdWriteMicromapsPropertiesEXT,                                    cmdWriteMicromapsPropertiesEXT),
4242         VK_NULL_FUNC_ENTRY(vkWriteMicromapsPropertiesEXT,                                               writeMicromapsPropertiesEXT),
4243         VK_NULL_FUNC_ENTRY(vkGetDeviceMicromapCompatibilityEXT,                                 getDeviceMicromapCompatibilityEXT),
4244         VK_NULL_FUNC_ENTRY(vkGetMicromapBuildSizesEXT,                                                  getMicromapBuildSizesEXT),
4245         VK_NULL_FUNC_ENTRY(vkGetShaderModuleIdentifierEXT,                                              getShaderModuleIdentifierEXT),
4246         VK_NULL_FUNC_ENTRY(vkGetShaderModuleCreateInfoIdentifierEXT,                    getShaderModuleCreateInfoIdentifierEXT),
4247         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout2EXT,                                             getImageSubresourceLayout2EXT),
4248         VK_NULL_FUNC_ENTRY(vkGetPipelinePropertiesEXT,                                                  getPipelinePropertiesEXT),
4249         VK_NULL_FUNC_ENTRY(vkExportMetalObjectsEXT,                                                             exportMetalObjectsEXT),
4250         VK_NULL_FUNC_ENTRY(vkGetFramebufferTilePropertiesQCOM,                                  getFramebufferTilePropertiesQCOM),
4251         VK_NULL_FUNC_ENTRY(vkGetDynamicRenderingTilePropertiesQCOM,                             getDynamicRenderingTilePropertiesQCOM),
4252         VK_NULL_FUNC_ENTRY(vkCreateOpticalFlowSessionNV,                                                createOpticalFlowSessionNV),
4253         VK_NULL_FUNC_ENTRY(vkDestroyOpticalFlowSessionNV,                                               destroyOpticalFlowSessionNV),
4254         VK_NULL_FUNC_ENTRY(vkBindOpticalFlowSessionImageNV,                                             bindOpticalFlowSessionImageNV),
4255         VK_NULL_FUNC_ENTRY(vkCmdOpticalFlowExecuteNV,                                                   cmdOpticalFlowExecuteNV),
4256         VK_NULL_FUNC_ENTRY(vkGetDeviceFaultInfoEXT,                                                             getDeviceFaultInfoEXT),
4257 };
4258