icd/generated/mock_icd.cpp

   1 /*
   2 ** Copyright (c) 2015-2018 The Khronos Group Inc.
   3 **
   4 ** Licensed under the Apache License, Version 2.0 (the "License");
   5 ** you may not use this file except in compliance with the License.
   6 ** You may obtain a copy of the License at
   7 **
   8 **     http://www.apache.org/licenses/LICENSE-2.0
   9 **
  10 ** Unless required by applicable law or agreed to in writing, software
  11 ** distributed under the License is distributed on an "AS IS" BASIS,
  12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 ** See the License for the specific language governing permissions and
  14 ** limitations under the License.
  15 */
  16
  17 /*
  18 ** This header is generated from the Khronos Vulkan XML API Registry.
  19 **
  20 */
  21
  22 #include "mock_icd.h"
  23 #include <stdlib.h>
  24 #include <algorithm>
  25 #include <array>
  26 #include <vector>
  27 #include "vk_typemap_helper.h"
  28 namespace vkmock {
  29
  30
  31 using std::unordered_map;
  32
  33 static constexpr uint32_t icd_physical_device_count = 1;
  34 static constexpr uint32_t kSupportedVulkanAPIVersion = VK_API_VERSION_1_1;
  35 static unordered_map<VkInstance, std::array<VkPhysicalDevice, icd_physical_device_count>> physical_device_map;
  36
  37 // Map device memory handle to any mapped allocations that we'll need to free on unmap
  38 static unordered_map<VkDeviceMemory, std::vector<void*>> mapped_memory_map;
  39
  40 // Map device memory allocation handle to the size
  41 static unordered_map<VkDeviceMemory, VkDeviceSize> allocated_memory_size_map;
  42
  43 static unordered_map<VkDevice, unordered_map<uint32_t, unordered_map<uint32_t, VkQueue>>> queue_map;
  44 static unordered_map<VkDevice, unordered_map<VkBuffer, VkBufferCreateInfo>> buffer_map;
  45 static unordered_map<VkDevice, unordered_map<VkImage, VkDeviceSize>> image_memory_size_map;
  46
  47 static constexpr uint32_t icd_swapchain_image_count = 1;
  48 static unordered_map<VkSwapchainKHR, VkImage[icd_swapchain_image_count]> swapchain_image_map;
  49
  50 // TODO: Would like to codegen this but limits aren't in XML
  51 static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits *limits) {
  52     limits->maxImageDimension1D = 4096;
  53     limits->maxImageDimension2D = 4096;
  54     limits->maxImageDimension3D = 256;
  55     limits->maxImageDimensionCube = 4096;
  56     limits->maxImageArrayLayers = 256;
  57     limits->maxTexelBufferElements = 65536;
  58     limits->maxUniformBufferRange = 16384;
  59     limits->maxStorageBufferRange = 134217728;
  60     limits->maxPushConstantsSize = 128;
  61     limits->maxMemoryAllocationCount = 4096;
  62     limits->maxSamplerAllocationCount = 4000;
  63     limits->bufferImageGranularity = 1;
  64     limits->sparseAddressSpaceSize = 2147483648;
  65     limits->maxBoundDescriptorSets = 4;
  66     limits->maxPerStageDescriptorSamplers = 16;
  67     limits->maxPerStageDescriptorUniformBuffers = 12;
  68     limits->maxPerStageDescriptorStorageBuffers = 4;
  69     limits->maxPerStageDescriptorSampledImages = 16;
  70     limits->maxPerStageDescriptorStorageImages = 4;
  71     limits->maxPerStageDescriptorInputAttachments = 4;
  72     limits->maxPerStageResources = 128;
  73     limits->maxDescriptorSetSamplers = 96;
  74     limits->maxDescriptorSetUniformBuffers = 72;
  75     limits->maxDescriptorSetUniformBuffersDynamic = 8;
  76     limits->maxDescriptorSetStorageBuffers = 24;
  77     limits->maxDescriptorSetStorageBuffersDynamic = 4;
  78     limits->maxDescriptorSetSampledImages = 96;
  79     limits->maxDescriptorSetStorageImages = 24;
  80     limits->maxDescriptorSetInputAttachments = 4;
  81     limits->maxVertexInputAttributes = 16;
  82     limits->maxVertexInputBindings = 16;
  83     limits->maxVertexInputAttributeOffset = 2047;
  84     limits->maxVertexInputBindingStride = 2048;
  85     limits->maxVertexOutputComponents = 64;
  86     limits->maxTessellationGenerationLevel = 64;
  87     limits->maxTessellationPatchSize = 32;
  88     limits->maxTessellationControlPerVertexInputComponents = 64;
  89     limits->maxTessellationControlPerVertexOutputComponents = 64;
  90     limits->maxTessellationControlPerPatchOutputComponents = 120;
  91     limits->maxTessellationControlTotalOutputComponents = 2048;
  92     limits->maxTessellationEvaluationInputComponents = 64;
  93     limits->maxTessellationEvaluationOutputComponents = 64;
  94     limits->maxGeometryShaderInvocations = 32;
  95     limits->maxGeometryInputComponents = 64;
  96     limits->maxGeometryOutputComponents = 64;
  97     limits->maxGeometryOutputVertices = 256;
  98     limits->maxGeometryTotalOutputComponents = 1024;
  99     limits->maxFragmentInputComponents = 64;
 100     limits->maxFragmentOutputAttachments = 4;
 101     limits->maxFragmentDualSrcAttachments = 1;
 102     limits->maxFragmentCombinedOutputResources = 4;
 103     limits->maxComputeSharedMemorySize = 16384;
 104     limits->maxComputeWorkGroupCount[0] = 65535;
 105     limits->maxComputeWorkGroupCount[1] = 65535;
 106     limits->maxComputeWorkGroupCount[2] = 65535;
 107     limits->maxComputeWorkGroupInvocations = 128;
 108     limits->maxComputeWorkGroupSize[0] = 128;
 109     limits->maxComputeWorkGroupSize[1] = 128;
 110     limits->maxComputeWorkGroupSize[2] = 64;
 111     limits->subPixelPrecisionBits = 4;
 112     limits->subTexelPrecisionBits = 4;
 113     limits->mipmapPrecisionBits = 4;
 114     limits->maxDrawIndexedIndexValue = UINT32_MAX;
 115     limits->maxDrawIndirectCount = UINT16_MAX;
 116     limits->maxSamplerLodBias = 2.0f;
 117     limits->maxSamplerAnisotropy = 16;
 118     limits->maxViewports = 16;
 119     limits->maxViewportDimensions[0] = 4096;
 120     limits->maxViewportDimensions[1] = 4096;
 121     limits->viewportBoundsRange[0] = -8192;
 122     limits->viewportBoundsRange[1] = 8191;
 123     limits->viewportSubPixelBits = 0;
 124     limits->minMemoryMapAlignment = 64;
 125     limits->minTexelBufferOffsetAlignment = 16;
 126     limits->minUniformBufferOffsetAlignment = 16;
 127     limits->minStorageBufferOffsetAlignment = 16;
 128     limits->minTexelOffset = -8;
 129     limits->maxTexelOffset = 7;
 130     limits->minTexelGatherOffset = -8;
 131     limits->maxTexelGatherOffset = 7;
 132     limits->minInterpolationOffset = 0.0f;
 133     limits->maxInterpolationOffset = 0.5f;
 134     limits->subPixelInterpolationOffsetBits = 4;
 135     limits->maxFramebufferWidth = 4096;
 136     limits->maxFramebufferHeight = 4096;
 137     limits->maxFramebufferLayers = 256;
 138     limits->framebufferColorSampleCounts = 0x7F;
 139     limits->framebufferDepthSampleCounts = 0x7F;
 140     limits->framebufferStencilSampleCounts = 0x7F;
 141     limits->framebufferNoAttachmentsSampleCounts = 0x7F;
 142     limits->maxColorAttachments = 4;
 143     limits->sampledImageColorSampleCounts = 0x7F;
 144     limits->sampledImageIntegerSampleCounts = 0x7F;
 145     limits->sampledImageDepthSampleCounts = 0x7F;
 146     limits->sampledImageStencilSampleCounts = 0x7F;
 147     limits->storageImageSampleCounts = 0x7F;
 148     limits->maxSampleMaskWords = 1;
 149     limits->timestampComputeAndGraphics = VK_TRUE;
 150     limits->timestampPeriod = 1;
 151     limits->maxClipDistances = 8;
 152     limits->maxCullDistances = 8;
 153     limits->maxCombinedClipAndCullDistances = 8;
 154     limits->discreteQueuePriorities = 2;
 155     limits->pointSizeRange[0] = 1.0f;
 156     limits->pointSizeRange[1] = 64.0f;
 157     limits->lineWidthRange[0] = 1.0f;
 158     limits->lineWidthRange[1] = 8.0f;
 159     limits->pointSizeGranularity = 1.0f;
 160     limits->lineWidthGranularity = 1.0f;
 161     limits->strictLines = VK_TRUE;
 162     limits->standardSampleLocations = VK_TRUE;
 163     limits->optimalBufferCopyOffsetAlignment = 1;
 164     limits->optimalBufferCopyRowPitchAlignment = 1;
 165     limits->nonCoherentAtomSize = 256;
 166
 167     return *limits;
 168 }
 169
 170 void SetBoolArrayTrue(VkBool32* bool_array, uint32_t num_bools)
 171 {
 172     for (uint32_t i = 0; i < num_bools; ++i) {
 173         bool_array[i] = VK_TRUE;
 174     }
 175 }
 176
 177
 178
 179 static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
 180     const VkInstanceCreateInfo*                 pCreateInfo,
 181     const VkAllocationCallbacks*                pAllocator,
 182     VkInstance*                                 pInstance)
 183 {
 184
 185     // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with
 186     //  apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the
 187     //  ICD should behave as normal.
 188     if (loader_interface_version <= 4) {
 189         return VK_ERROR_INCOMPATIBLE_DRIVER;
 190     }
 191     *pInstance = (VkInstance)CreateDispObjHandle();
 192     for (auto& physical_device : physical_device_map[*pInstance])
 193         physical_device = (VkPhysicalDevice)CreateDispObjHandle();
 194     // TODO: If emulating specific device caps, will need to add intelligence here
 195     return VK_SUCCESS;
 196 }
 197
 198 static VKAPI_ATTR void VKAPI_CALL DestroyInstance(
 199     VkInstance                                  instance,
 200     const VkAllocationCallbacks*                pAllocator)
 201 {
 202
 203     if (instance) {
 204         for (const auto physical_device : physical_device_map.at(instance))
 205             DestroyDispObjHandle((void*)physical_device);
 206         physical_device_map.erase(instance);
 207         DestroyDispObjHandle((void*)instance);
 208     }
 209 }
 210
 211 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
 212     VkInstance                                  instance,
 213     uint32_t*                                   pPhysicalDeviceCount,
 214     VkPhysicalDevice*                           pPhysicalDevices)
 215 {
 216     VkResult result_code = VK_SUCCESS;
 217     if (pPhysicalDevices) {
 218         const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count);
 219         for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i];
 220         if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE;
 221         *pPhysicalDeviceCount = return_count;
 222     } else {
 223         *pPhysicalDeviceCount = icd_physical_device_count;
 224     }
 225     return result_code;
 226 }
 227
 228 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
 229     VkPhysicalDevice                            physicalDevice,
 230     VkPhysicalDeviceFeatures*                   pFeatures)
 231 {
 232     uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
 233     VkBool32 *bool_array = &pFeatures->robustBufferAccess;
 234     SetBoolArrayTrue(bool_array, num_bools);
 235 }
 236
 237 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
 238     VkPhysicalDevice                            physicalDevice,
 239     VkFormat                                    format,
 240     VkFormatProperties*                         pFormatProperties)
 241 {
 242     if (VK_FORMAT_UNDEFINED == format) {
 243         *pFormatProperties = { 0x0, 0x0, 0x0 };
 244     } else {
 245         // Default to a color format, skip DS bit
 246         *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF };
 247         switch (format) {
 248             case VK_FORMAT_D16_UNORM:
 249             case VK_FORMAT_X8_D24_UNORM_PACK32:
 250             case VK_FORMAT_D32_SFLOAT:
 251             case VK_FORMAT_S8_UINT:
 252             case VK_FORMAT_D16_UNORM_S8_UINT:
 253             case VK_FORMAT_D24_UNORM_S8_UINT:
 254             case VK_FORMAT_D32_SFLOAT_S8_UINT:
 255                 // Don't set color bits for DS formats
 256                 *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F };
 257                 break;
 258             default:
 259                 break;
 260         }
 261     }
 262 }
 263
 264 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
 265     VkPhysicalDevice                            physicalDevice,
 266     VkFormat                                    format,
 267     VkImageType                                 type,
 268     VkImageTiling                               tiling,
 269     VkImageUsageFlags                           usage,
 270     VkImageCreateFlags                          flags,
 271     VkImageFormatProperties*                    pImageFormatProperties)
 272 {
 273     // A hardcoded unsupported format
 274     if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
 275         return VK_ERROR_FORMAT_NOT_SUPPORTED;
 276     }
 277
 278     // TODO: Just hard-coding some values for now
 279     // TODO: If tiling is linear, limit the mips, levels, & sample count
 280     if (VK_IMAGE_TILING_LINEAR == tiling) {
 281         *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 };
 282     } else {
 283         // We hard-code support for all sample counts except 64 bits.
 284         *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 };
 285     }
 286     return VK_SUCCESS;
 287 }
 288
 289 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
 290     VkPhysicalDevice                            physicalDevice,
 291     VkPhysicalDeviceProperties*                 pProperties)
 292 {
 293     // TODO: Just hard-coding some values for now
 294     pProperties->apiVersion = kSupportedVulkanAPIVersion;
 295     pProperties->driverVersion = 1;
 296     pProperties->vendorID = 0xba5eba11;
 297     pProperties->deviceID = 0xf005ba11;
 298     pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
 299     //std::string devName = "Vulkan Mock Device";
 300     strcpy(pProperties->deviceName, "Vulkan Mock Device");
 301     pProperties->pipelineCacheUUID[0] = 18;
 302     pProperties->limits = SetLimits(&pProperties->limits);
 303     pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE };
 304 }
 305
 306 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
 307     VkPhysicalDevice                            physicalDevice,
 308     uint32_t*                                   pQueueFamilyPropertyCount,
 309     VkQueueFamilyProperties*                    pQueueFamilyProperties)
 310 {
 311     if (!pQueueFamilyProperties) {
 312         *pQueueFamilyPropertyCount = 1;
 313     } else {
 314         if (*pQueueFamilyPropertyCount) {
 315             pQueueFamilyProperties[0].queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT;
 316             pQueueFamilyProperties[0].queueCount = 1;
 317             pQueueFamilyProperties[0].timestampValidBits = 0;
 318             pQueueFamilyProperties[0].minImageTransferGranularity = {1,1,1};
 319         }
 320     }
 321 }
 322
 323 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
 324     VkPhysicalDevice                            physicalDevice,
 325     VkPhysicalDeviceMemoryProperties*           pMemoryProperties)
 326 {
 327     pMemoryProperties->memoryTypeCount = 2;
 328     pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 329     pMemoryProperties->memoryTypes[0].heapIndex = 0;
 330     pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 331     pMemoryProperties->memoryTypes[1].heapIndex = 1;
 332     pMemoryProperties->memoryHeapCount = 2;
 333     pMemoryProperties->memoryHeaps[0].flags = 0;
 334     pMemoryProperties->memoryHeaps[0].size = 8000000000;
 335     pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
 336     pMemoryProperties->memoryHeaps[1].size = 8000000000;
 337 }
 338
 339 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
 340     VkInstance                                  instance,
 341     const char*                                 pName)
 342 {
 343
 344     if (!negotiate_loader_icd_interface_called) {
 345         loader_interface_version = 0;
 346     }
 347     const auto &item = name_to_funcptr_map.find(pName);
 348     if (item != name_to_funcptr_map.end()) {
 349         return reinterpret_cast<PFN_vkVoidFunction>(item->second);
 350     }
 351     // Mock should intercept all functions so if we get here just return null
 352     return nullptr;
 353 }
 354
 355 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
 356     VkDevice                                    device,
 357     const char*                                 pName)
 358 {
 359
 360     return GetInstanceProcAddr(nullptr, pName);
 361 }
 362
 363 static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
 364     VkPhysicalDevice                            physicalDevice,
 365     const VkDeviceCreateInfo*                   pCreateInfo,
 366     const VkAllocationCallbacks*                pAllocator,
 367     VkDevice*                                   pDevice)
 368 {
 369
 370     *pDevice = (VkDevice)CreateDispObjHandle();
 371     // TODO: If emulating specific device caps, will need to add intelligence here
 372     return VK_SUCCESS;
 373 }
 374
 375 static VKAPI_ATTR void VKAPI_CALL DestroyDevice(
 376     VkDevice                                    device,
 377     const VkAllocationCallbacks*                pAllocator)
 378 {
 379
 380     unique_lock_t lock(global_lock);
 381     // First destroy sub-device objects
 382     // Destroy Queues
 383     for (auto dev_queue_map_pair : queue_map) {
 384         for (auto queue_family_map_pair : queue_map[dev_queue_map_pair.first]) {
 385             for (auto index_queue_pair : queue_map[dev_queue_map_pair.first][queue_family_map_pair.first]) {
 386                 DestroyDispObjHandle((void*)index_queue_pair.second);
 387             }
 388         }
 389     }
 390     queue_map.clear();
 391     buffer_map.erase(device);
 392     image_memory_size_map.erase(device);
 393     // Now destroy device
 394     DestroyDispObjHandle((void*)device);
 395     // TODO: If emulating specific device caps, will need to add intelligence here
 396 }
 397
 398 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
 399     const char*                                 pLayerName,
 400     uint32_t*                                   pPropertyCount,
 401     VkExtensionProperties*                      pProperties)
 402 {
 403
 404     // If requesting number of extensions, return that
 405     if (!pLayerName) {
 406         if (!pProperties) {
 407             *pPropertyCount = (uint32_t)instance_extension_map.size();
 408         } else {
 409             uint32_t i = 0;
 410             for (const auto &name_ver_pair : instance_extension_map) {
 411                 if (i == *pPropertyCount) {
 412                     break;
 413                 }
 414                 std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
 415                 pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
 416                 pProperties[i].specVersion = name_ver_pair.second;
 417                 ++i;
 418             }
 419             if (i != instance_extension_map.size()) {
 420                 return VK_INCOMPLETE;
 421             }
 422         }
 423     }
 424     // If requesting extension properties, fill in data struct for number of extensions
 425     return VK_SUCCESS;
 426 }
 427
 428 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
 429     VkPhysicalDevice                            physicalDevice,
 430     const char*                                 pLayerName,
 431     uint32_t*                                   pPropertyCount,
 432     VkExtensionProperties*                      pProperties)
 433 {
 434
 435     // If requesting number of extensions, return that
 436     if (!pLayerName) {
 437         if (!pProperties) {
 438             *pPropertyCount = (uint32_t)device_extension_map.size();
 439         } else {
 440             uint32_t i = 0;
 441             for (const auto &name_ver_pair : device_extension_map) {
 442                 if (i == *pPropertyCount) {
 443                     break;
 444                 }
 445                 std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
 446                 pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
 447                 pProperties[i].specVersion = name_ver_pair.second;
 448                 ++i;
 449             }
 450             if (i != device_extension_map.size()) {
 451                 return VK_INCOMPLETE;
 452             }
 453         }
 454     }
 455     // If requesting extension properties, fill in data struct for number of extensions
 456     return VK_SUCCESS;
 457 }
 458
 459 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
 460     uint32_t*                                   pPropertyCount,
 461     VkLayerProperties*                          pProperties)
 462 {
 463
 464     return VK_SUCCESS;
 465 }
 466
 467 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
 468     VkPhysicalDevice                            physicalDevice,
 469     uint32_t*                                   pPropertyCount,
 470     VkLayerProperties*                          pProperties)
 471 {
 472
 473     return VK_SUCCESS;
 474 }
 475
 476 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
 477     VkDevice                                    device,
 478     uint32_t                                    queueFamilyIndex,
 479     uint32_t                                    queueIndex,
 480     VkQueue*                                    pQueue)
 481 {
 482     unique_lock_t lock(global_lock);
 483     auto queue = queue_map[device][queueFamilyIndex][queueIndex];
 484     if (queue) {
 485         *pQueue = queue;
 486     } else {
 487         *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle();
 488     }
 489     // TODO: If emulating specific device caps, will need to add intelligence here
 490     return;
 491 }
 492
 493 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
 494     VkQueue                                     queue,
 495     uint32_t                                    submitCount,
 496     const VkSubmitInfo*                         pSubmits,
 497     VkFence                                     fence)
 498 {
 499 //Not a CREATE or DESTROY function
 500     return VK_SUCCESS;
 501 }
 502
 503 static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
 504     VkQueue                                     queue)
 505 {
 506 //Not a CREATE or DESTROY function
 507     return VK_SUCCESS;
 508 }
 509
 510 static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
 511     VkDevice                                    device)
 512 {
 513 //Not a CREATE or DESTROY function
 514     return VK_SUCCESS;
 515 }
 516
 517 static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
 518     VkDevice                                    device,
 519     const VkMemoryAllocateInfo*                 pAllocateInfo,
 520     const VkAllocationCallbacks*                pAllocator,
 521     VkDeviceMemory*                             pMemory)
 522 {
 523     unique_lock_t lock(global_lock);
 524     allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;
 525     *pMemory = (VkDeviceMemory)global_unique_handle++;
 526     return VK_SUCCESS;
 527 }
 528
 529 static VKAPI_ATTR void VKAPI_CALL FreeMemory(
 530     VkDevice                                    device,
 531     VkDeviceMemory                              memory,
 532     const VkAllocationCallbacks*                pAllocator)
 533 {
 534 //Destroy object
 535     allocated_memory_size_map.erase(memory);
 536 }
 537
 538 static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
 539     VkDevice                                    device,
 540     VkDeviceMemory                              memory,
 541     VkDeviceSize                                offset,
 542     VkDeviceSize                                size,
 543     VkMemoryMapFlags                            flags,
 544     void**                                      ppData)
 545 {
 546     unique_lock_t lock(global_lock);
 547     if (VK_WHOLE_SIZE == size) {
 548         if (allocated_memory_size_map.count(memory) != 0)
 549             size = allocated_memory_size_map[memory] - offset;
 550         else
 551             size = 0x10000;
 552     }
 553     void* map_addr = malloc((size_t)size);
 554     mapped_memory_map[memory].push_back(map_addr);
 555     *ppData = map_addr;
 556     return VK_SUCCESS;
 557 }
 558
 559 static VKAPI_ATTR void VKAPI_CALL UnmapMemory(
 560     VkDevice                                    device,
 561     VkDeviceMemory                              memory)
 562 {
 563     unique_lock_t lock(global_lock);
 564     for (auto map_addr : mapped_memory_map[memory]) {
 565         free(map_addr);
 566     }
 567     mapped_memory_map.erase(memory);
 568 }
 569
 570 static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
 571     VkDevice                                    device,
 572     uint32_t                                    memoryRangeCount,
 573     const VkMappedMemoryRange*                  pMemoryRanges)
 574 {
 575 //Not a CREATE or DESTROY function
 576     return VK_SUCCESS;
 577 }
 578
 579 static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
 580     VkDevice                                    device,
 581     uint32_t                                    memoryRangeCount,
 582     const VkMappedMemoryRange*                  pMemoryRanges)
 583 {
 584 //Not a CREATE or DESTROY function
 585     return VK_SUCCESS;
 586 }
 587
 588 static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
 589     VkDevice                                    device,
 590     VkDeviceMemory                              memory,
 591     VkDeviceSize*                               pCommittedMemoryInBytes)
 592 {
 593 //Not a CREATE or DESTROY function
 594 }
 595
 596 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
 597     VkDevice                                    device,
 598     VkBuffer                                    buffer,
 599     VkDeviceMemory                              memory,
 600     VkDeviceSize                                memoryOffset)
 601 {
 602 //Not a CREATE or DESTROY function
 603     return VK_SUCCESS;
 604 }
 605
 606 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
 607     VkDevice                                    device,
 608     VkImage                                     image,
 609     VkDeviceMemory                              memory,
 610     VkDeviceSize                                memoryOffset)
 611 {
 612 //Not a CREATE or DESTROY function
 613     return VK_SUCCESS;
 614 }
 615
 616 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
 617     VkDevice                                    device,
 618     VkBuffer                                    buffer,
 619     VkMemoryRequirements*                       pMemoryRequirements)
 620 {
 621     // TODO: Just hard-coding reqs for now
 622     pMemoryRequirements->size = 4096;
 623     pMemoryRequirements->alignment = 1;
 624     pMemoryRequirements->memoryTypeBits = 0xFFFF;
 625     // Return a better size based on the buffer size from the create info.
 626     auto d_iter = buffer_map.find(device);
 627     if (d_iter != buffer_map.end()) {
 628         auto iter = d_iter->second.find(buffer);
 629         if (iter != d_iter->second.end()) {
 630             pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096;
 631         }
 632     }
 633 }
 634
 635 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
 636     VkDevice                                    device,
 637     VkImage                                     image,
 638     VkMemoryRequirements*                       pMemoryRequirements)
 639 {
 640     pMemoryRequirements->size = 0;
 641     pMemoryRequirements->alignment = 1;
 642
 643     auto d_iter = image_memory_size_map.find(device);
 644     if(d_iter != image_memory_size_map.end()){
 645         auto iter = d_iter->second.find(image);
 646         if (iter != d_iter->second.end()) {
 647             pMemoryRequirements->size = iter->second;
 648         }
 649     }
 650     // Here we hard-code that the memory type at index 3 doesn't support this image.
 651     pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3);
 652 }
 653
 654 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
 655     VkDevice                                    device,
 656     VkImage                                     image,
 657     uint32_t*                                   pSparseMemoryRequirementCount,
 658     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements)
 659 {
 660 //Not a CREATE or DESTROY function
 661 }
 662
 663 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
 664     VkPhysicalDevice                            physicalDevice,
 665     VkFormat                                    format,
 666     VkImageType                                 type,
 667     VkSampleCountFlagBits                       samples,
 668     VkImageUsageFlags                           usage,
 669     VkImageTiling                               tiling,
 670     uint32_t*                                   pPropertyCount,
 671     VkSparseImageFormatProperties*              pProperties)
 672 {
 673 //Not a CREATE or DESTROY function
 674 }
 675
 676 static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
 677     VkQueue                                     queue,
 678     uint32_t                                    bindInfoCount,
 679     const VkBindSparseInfo*                     pBindInfo,
 680     VkFence                                     fence)
 681 {
 682 //Not a CREATE or DESTROY function
 683     return VK_SUCCESS;
 684 }
 685
 686 static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
 687     VkDevice                                    device,
 688     const VkFenceCreateInfo*                    pCreateInfo,
 689     const VkAllocationCallbacks*                pAllocator,
 690     VkFence*                                    pFence)
 691 {
 692     unique_lock_t lock(global_lock);
 693     *pFence = (VkFence)global_unique_handle++;
 694     return VK_SUCCESS;
 695 }
 696
 697 static VKAPI_ATTR void VKAPI_CALL DestroyFence(
 698     VkDevice                                    device,
 699     VkFence                                     fence,
 700     const VkAllocationCallbacks*                pAllocator)
 701 {
 702 //Destroy object
 703 }
 704
 705 static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
 706     VkDevice                                    device,
 707     uint32_t                                    fenceCount,
 708     const VkFence*                              pFences)
 709 {
 710 //Not a CREATE or DESTROY function
 711     return VK_SUCCESS;
 712 }
 713
 714 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
 715     VkDevice                                    device,
 716     VkFence                                     fence)
 717 {
 718 //Not a CREATE or DESTROY function
 719     return VK_SUCCESS;
 720 }
 721
 722 static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
 723     VkDevice                                    device,
 724     uint32_t                                    fenceCount,
 725     const VkFence*                              pFences,
 726     VkBool32                                    waitAll,
 727     uint64_t                                    timeout)
 728 {
 729 //Not a CREATE or DESTROY function
 730     return VK_SUCCESS;
 731 }
 732
 733 static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
 734     VkDevice                                    device,
 735     const VkSemaphoreCreateInfo*                pCreateInfo,
 736     const VkAllocationCallbacks*                pAllocator,
 737     VkSemaphore*                                pSemaphore)
 738 {
 739     unique_lock_t lock(global_lock);
 740     *pSemaphore = (VkSemaphore)global_unique_handle++;
 741     return VK_SUCCESS;
 742 }
 743
 744 static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
 745     VkDevice                                    device,
 746     VkSemaphore                                 semaphore,
 747     const VkAllocationCallbacks*                pAllocator)
 748 {
 749 //Destroy object
 750 }
 751
 752 static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
 753     VkDevice                                    device,
 754     const VkEventCreateInfo*                    pCreateInfo,
 755     const VkAllocationCallbacks*                pAllocator,
 756     VkEvent*                                    pEvent)
 757 {
 758     unique_lock_t lock(global_lock);
 759     *pEvent = (VkEvent)global_unique_handle++;
 760     return VK_SUCCESS;
 761 }
 762
 763 static VKAPI_ATTR void VKAPI_CALL DestroyEvent(
 764     VkDevice                                    device,
 765     VkEvent                                     event,
 766     const VkAllocationCallbacks*                pAllocator)
 767 {
 768 //Destroy object
 769 }
 770
 771 static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
 772     VkDevice                                    device,
 773     VkEvent                                     event)
 774 {
 775 //Not a CREATE or DESTROY function
 776     return VK_EVENT_SET;
 777 }
 778
 779 static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
 780     VkDevice                                    device,
 781     VkEvent                                     event)
 782 {
 783 //Not a CREATE or DESTROY function
 784     return VK_SUCCESS;
 785 }
 786
 787 static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
 788     VkDevice                                    device,
 789     VkEvent                                     event)
 790 {
 791 //Not a CREATE or DESTROY function
 792     return VK_SUCCESS;
 793 }
 794
 795 static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
 796     VkDevice                                    device,
 797     const VkQueryPoolCreateInfo*                pCreateInfo,
 798     const VkAllocationCallbacks*                pAllocator,
 799     VkQueryPool*                                pQueryPool)
 800 {
 801     unique_lock_t lock(global_lock);
 802     *pQueryPool = (VkQueryPool)global_unique_handle++;
 803     return VK_SUCCESS;
 804 }
 805
 806 static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
 807     VkDevice                                    device,
 808     VkQueryPool                                 queryPool,
 809     const VkAllocationCallbacks*                pAllocator)
 810 {
 811 //Destroy object
 812 }
 813
 814 static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
 815     VkDevice                                    device,
 816     VkQueryPool                                 queryPool,
 817     uint32_t                                    firstQuery,
 818     uint32_t                                    queryCount,
 819     size_t                                      dataSize,
 820     void*                                       pData,
 821     VkDeviceSize                                stride,
 822     VkQueryResultFlags                          flags)
 823 {
 824 //Not a CREATE or DESTROY function
 825     return VK_SUCCESS;
 826 }
 827
 828 static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
 829     VkDevice                                    device,
 830     const VkBufferCreateInfo*                   pCreateInfo,
 831     const VkAllocationCallbacks*                pAllocator,
 832     VkBuffer*                                   pBuffer)
 833 {
 834     unique_lock_t lock(global_lock);
 835     *pBuffer = (VkBuffer)global_unique_handle++;
 836     buffer_map[device][*pBuffer] = *pCreateInfo;
 837     return VK_SUCCESS;
 838 }
 839
 840 static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
 841     VkDevice                                    device,
 842     VkBuffer                                    buffer,
 843     const VkAllocationCallbacks*                pAllocator)
 844 {
 845     unique_lock_t lock(global_lock);
 846     buffer_map[device].erase(buffer);
 847 }
 848
 849 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
 850     VkDevice                                    device,
 851     const VkBufferViewCreateInfo*               pCreateInfo,
 852     const VkAllocationCallbacks*                pAllocator,
 853     VkBufferView*                               pView)
 854 {
 855     unique_lock_t lock(global_lock);
 856     *pView = (VkBufferView)global_unique_handle++;
 857     return VK_SUCCESS;
 858 }
 859
 860 static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
 861     VkDevice                                    device,
 862     VkBufferView                                bufferView,
 863     const VkAllocationCallbacks*                pAllocator)
 864 {
 865 //Destroy object
 866 }
 867
 868 static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
 869     VkDevice                                    device,
 870     const VkImageCreateInfo*                    pCreateInfo,
 871     const VkAllocationCallbacks*                pAllocator,
 872     VkImage*                                    pImage)
 873 {
 874     unique_lock_t lock(global_lock);
 875     *pImage = (VkImage)global_unique_handle++;
 876     // TODO: A pixel size is 32 bytes. This accounts for the largest possible pixel size of any format. It could be changed to more accurate size if need be.
 877     image_memory_size_map[device][*pImage] = pCreateInfo->extent.width * pCreateInfo->extent.height * pCreateInfo->extent.depth *
 878                                              32 * pCreateInfo->arrayLayers * (pCreateInfo->mipLevels > 1 ? 2 : 1);
 879     // plane count
 880     switch (pCreateInfo->format) {
 881         case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
 882         case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
 883         case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
 884         case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
 885         case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
 886         case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
 887         case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
 888         case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
 889         case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
 890         case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
 891         case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
 892         case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
 893             image_memory_size_map[device][*pImage] *= 3;
 894             break;
 895         case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
 896         case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
 897         case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
 898         case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
 899         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
 900         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
 901         case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
 902         case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
 903             image_memory_size_map[device][*pImage] *= 2;
 904             break;
 905         default:
 906             break;
 907     }
 908     return VK_SUCCESS;
 909 }
 910
 911 static VKAPI_ATTR void VKAPI_CALL DestroyImage(
 912     VkDevice                                    device,
 913     VkImage                                     image,
 914     const VkAllocationCallbacks*                pAllocator)
 915 {
 916     unique_lock_t lock(global_lock);
 917     image_memory_size_map[device].erase(image);
 918 }
 919
 920 static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
 921     VkDevice                                    device,
 922     VkImage                                     image,
 923     const VkImageSubresource*                   pSubresource,
 924     VkSubresourceLayout*                        pLayout)
 925 {
 926     // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure.
 927     *pLayout = VkSubresourceLayout(); // Default constructor zero values.
 928 }
 929
 930 static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
 931     VkDevice                                    device,
 932     const VkImageViewCreateInfo*                pCreateInfo,
 933     const VkAllocationCallbacks*                pAllocator,
 934     VkImageView*                                pView)
 935 {
 936     unique_lock_t lock(global_lock);
 937     *pView = (VkImageView)global_unique_handle++;
 938     return VK_SUCCESS;
 939 }
 940
 941 static VKAPI_ATTR void VKAPI_CALL DestroyImageView(
 942     VkDevice                                    device,
 943     VkImageView                                 imageView,
 944     const VkAllocationCallbacks*                pAllocator)
 945 {
 946 //Destroy object
 947 }
 948
 949 static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
 950     VkDevice                                    device,
 951     const VkShaderModuleCreateInfo*             pCreateInfo,
 952     const VkAllocationCallbacks*                pAllocator,
 953     VkShaderModule*                             pShaderModule)
 954 {
 955     unique_lock_t lock(global_lock);
 956     *pShaderModule = (VkShaderModule)global_unique_handle++;
 957     return VK_SUCCESS;
 958 }
 959
 960 static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
 961     VkDevice                                    device,
 962     VkShaderModule                              shaderModule,
 963     const VkAllocationCallbacks*                pAllocator)
 964 {
 965 //Destroy object
 966 }
 967
 968 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
 969     VkDevice                                    device,
 970     const VkPipelineCacheCreateInfo*            pCreateInfo,
 971     const VkAllocationCallbacks*                pAllocator,
 972     VkPipelineCache*                            pPipelineCache)
 973 {
 974     unique_lock_t lock(global_lock);
 975     *pPipelineCache = (VkPipelineCache)global_unique_handle++;
 976     return VK_SUCCESS;
 977 }
 978
 979 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
 980     VkDevice                                    device,
 981     VkPipelineCache                             pipelineCache,
 982     const VkAllocationCallbacks*                pAllocator)
 983 {
 984 //Destroy object
 985 }
 986
 987 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
 988     VkDevice                                    device,
 989     VkPipelineCache                             pipelineCache,
 990     size_t*                                     pDataSize,
 991     void*                                       pData)
 992 {
 993 //Not a CREATE or DESTROY function
 994     return VK_SUCCESS;
 995 }
 996
 997 static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
 998     VkDevice                                    device,
 999     VkPipelineCache                             dstCache,
1000     uint32_t                                    srcCacheCount,
1001     const VkPipelineCache*                      pSrcCaches)
1002 {
1003 //Not a CREATE or DESTROY function
1004     return VK_SUCCESS;
1005 }
1006
1007 static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
1008     VkDevice                                    device,
1009     VkPipelineCache                             pipelineCache,
1010     uint32_t                                    createInfoCount,
1011     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
1012     const VkAllocationCallbacks*                pAllocator,
1013     VkPipeline*                                 pPipelines)
1014 {
1015     unique_lock_t lock(global_lock);
1016     for (uint32_t i = 0; i < createInfoCount; ++i) {
1017         pPipelines[i] = (VkPipeline)global_unique_handle++;
1018     }
1019     return VK_SUCCESS;
1020 }
1021
1022 static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
1023     VkDevice                                    device,
1024     VkPipelineCache                             pipelineCache,
1025     uint32_t                                    createInfoCount,
1026     const VkComputePipelineCreateInfo*          pCreateInfos,
1027     const VkAllocationCallbacks*                pAllocator,
1028     VkPipeline*                                 pPipelines)
1029 {
1030     unique_lock_t lock(global_lock);
1031     for (uint32_t i = 0; i < createInfoCount; ++i) {
1032         pPipelines[i] = (VkPipeline)global_unique_handle++;
1033     }
1034     return VK_SUCCESS;
1035 }
1036
1037 static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
1038     VkDevice                                    device,
1039     VkPipeline                                  pipeline,
1040     const VkAllocationCallbacks*                pAllocator)
1041 {
1042 //Destroy object
1043 }
1044
1045 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
1046     VkDevice                                    device,
1047     const VkPipelineLayoutCreateInfo*           pCreateInfo,
1048     const VkAllocationCallbacks*                pAllocator,
1049     VkPipelineLayout*                           pPipelineLayout)
1050 {
1051     unique_lock_t lock(global_lock);
1052     *pPipelineLayout = (VkPipelineLayout)global_unique_handle++;
1053     return VK_SUCCESS;
1054 }
1055
1056 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
1057     VkDevice                                    device,
1058     VkPipelineLayout                            pipelineLayout,
1059     const VkAllocationCallbacks*                pAllocator)
1060 {
1061 //Destroy object
1062 }
1063
1064 static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
1065     VkDevice                                    device,
1066     const VkSamplerCreateInfo*                  pCreateInfo,
1067     const VkAllocationCallbacks*                pAllocator,
1068     VkSampler*                                  pSampler)
1069 {
1070     unique_lock_t lock(global_lock);
1071     *pSampler = (VkSampler)global_unique_handle++;
1072     return VK_SUCCESS;
1073 }
1074
1075 static VKAPI_ATTR void VKAPI_CALL DestroySampler(
1076     VkDevice                                    device,
1077     VkSampler                                   sampler,
1078     const VkAllocationCallbacks*                pAllocator)
1079 {
1080 //Destroy object
1081 }
1082
1083 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
1084     VkDevice                                    device,
1085     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1086     const VkAllocationCallbacks*                pAllocator,
1087     VkDescriptorSetLayout*                      pSetLayout)
1088 {
1089     unique_lock_t lock(global_lock);
1090     *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++;
1091     return VK_SUCCESS;
1092 }
1093
1094 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
1095     VkDevice                                    device,
1096     VkDescriptorSetLayout                       descriptorSetLayout,
1097     const VkAllocationCallbacks*                pAllocator)
1098 {
1099 //Destroy object
1100 }
1101
1102 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
1103     VkDevice                                    device,
1104     const VkDescriptorPoolCreateInfo*           pCreateInfo,
1105     const VkAllocationCallbacks*                pAllocator,
1106     VkDescriptorPool*                           pDescriptorPool)
1107 {
1108     unique_lock_t lock(global_lock);
1109     *pDescriptorPool = (VkDescriptorPool)global_unique_handle++;
1110     return VK_SUCCESS;
1111 }
1112
1113 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
1114     VkDevice                                    device,
1115     VkDescriptorPool                            descriptorPool,
1116     const VkAllocationCallbacks*                pAllocator)
1117 {
1118 //Destroy object
1119 }
1120
1121 static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
1122     VkDevice                                    device,
1123     VkDescriptorPool                            descriptorPool,
1124     VkDescriptorPoolResetFlags                  flags)
1125 {
1126 //Not a CREATE or DESTROY function
1127     return VK_SUCCESS;
1128 }
1129
1130 static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
1131     VkDevice                                    device,
1132     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
1133     VkDescriptorSet*                            pDescriptorSets)
1134 {
1135     unique_lock_t lock(global_lock);
1136     for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
1137         pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++;
1138     }
1139     return VK_SUCCESS;
1140 }
1141
1142 static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
1143     VkDevice                                    device,
1144     VkDescriptorPool                            descriptorPool,
1145     uint32_t                                    descriptorSetCount,
1146     const VkDescriptorSet*                      pDescriptorSets)
1147 {
1148 //Destroy object
1149     return VK_SUCCESS;
1150 }
1151
1152 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
1153     VkDevice                                    device,
1154     uint32_t                                    descriptorWriteCount,
1155     const VkWriteDescriptorSet*                 pDescriptorWrites,
1156     uint32_t                                    descriptorCopyCount,
1157     const VkCopyDescriptorSet*                  pDescriptorCopies)
1158 {
1159 //Not a CREATE or DESTROY function
1160 }
1161
1162 static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
1163     VkDevice                                    device,
1164     const VkFramebufferCreateInfo*              pCreateInfo,
1165     const VkAllocationCallbacks*                pAllocator,
1166     VkFramebuffer*                              pFramebuffer)
1167 {
1168     unique_lock_t lock(global_lock);
1169     *pFramebuffer = (VkFramebuffer)global_unique_handle++;
1170     return VK_SUCCESS;
1171 }
1172
1173 static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
1174     VkDevice                                    device,
1175     VkFramebuffer                               framebuffer,
1176     const VkAllocationCallbacks*                pAllocator)
1177 {
1178 //Destroy object
1179 }
1180
1181 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
1182     VkDevice                                    device,
1183     const VkRenderPassCreateInfo*               pCreateInfo,
1184     const VkAllocationCallbacks*                pAllocator,
1185     VkRenderPass*                               pRenderPass)
1186 {
1187     unique_lock_t lock(global_lock);
1188     *pRenderPass = (VkRenderPass)global_unique_handle++;
1189     return VK_SUCCESS;
1190 }
1191
1192 static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
1193     VkDevice                                    device,
1194     VkRenderPass                                renderPass,
1195     const VkAllocationCallbacks*                pAllocator)
1196 {
1197 //Destroy object
1198 }
1199
1200 static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
1201     VkDevice                                    device,
1202     VkRenderPass                                renderPass,
1203     VkExtent2D*                                 pGranularity)
1204 {
1205 //Not a CREATE or DESTROY function
1206 }
1207
1208 static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
1209     VkDevice                                    device,
1210     const VkCommandPoolCreateInfo*              pCreateInfo,
1211     const VkAllocationCallbacks*                pAllocator,
1212     VkCommandPool*                              pCommandPool)
1213 {
1214     unique_lock_t lock(global_lock);
1215     *pCommandPool = (VkCommandPool)global_unique_handle++;
1216     return VK_SUCCESS;
1217 }
1218
1219 static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
1220     VkDevice                                    device,
1221     VkCommandPool                               commandPool,
1222     const VkAllocationCallbacks*                pAllocator)
1223 {
1224 //Destroy object
1225 }
1226
1227 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
1228     VkDevice                                    device,
1229     VkCommandPool                               commandPool,
1230     VkCommandPoolResetFlags                     flags)
1231 {
1232 //Not a CREATE or DESTROY function
1233     return VK_SUCCESS;
1234 }
1235
1236 static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
1237     VkDevice                                    device,
1238     const VkCommandBufferAllocateInfo*          pAllocateInfo,
1239     VkCommandBuffer*                            pCommandBuffers)
1240 {
1241     unique_lock_t lock(global_lock);
1242     for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
1243         pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle();
1244     }
1245     return VK_SUCCESS;
1246 }
1247
1248 static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
1249     VkDevice                                    device,
1250     VkCommandPool                               commandPool,
1251     uint32_t                                    commandBufferCount,
1252     const VkCommandBuffer*                      pCommandBuffers)
1253 {
1254 //Destroy object
1255 }
1256
1257 static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
1258     VkCommandBuffer                             commandBuffer,
1259     const VkCommandBufferBeginInfo*             pBeginInfo)
1260 {
1261 //Not a CREATE or DESTROY function
1262     return VK_SUCCESS;
1263 }
1264
1265 static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
1266     VkCommandBuffer                             commandBuffer)
1267 {
1268 //Not a CREATE or DESTROY function
1269     return VK_SUCCESS;
1270 }
1271
1272 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
1273     VkCommandBuffer                             commandBuffer,
1274     VkCommandBufferResetFlags                   flags)
1275 {
1276 //Not a CREATE or DESTROY function
1277     return VK_SUCCESS;
1278 }
1279
1280 static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
1281     VkCommandBuffer                             commandBuffer,
1282     VkPipelineBindPoint                         pipelineBindPoint,
1283     VkPipeline                                  pipeline)
1284 {
1285 //Not a CREATE or DESTROY function
1286 }
1287
1288 static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
1289     VkCommandBuffer                             commandBuffer,
1290     uint32_t                                    firstViewport,
1291     uint32_t                                    viewportCount,
1292     const VkViewport*                           pViewports)
1293 {
1294 //Not a CREATE or DESTROY function
1295 }
1296
1297 static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
1298     VkCommandBuffer                             commandBuffer,
1299     uint32_t                                    firstScissor,
1300     uint32_t                                    scissorCount,
1301     const VkRect2D*                             pScissors)
1302 {
1303 //Not a CREATE or DESTROY function
1304 }
1305
1306 static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
1307     VkCommandBuffer                             commandBuffer,
1308     float                                       lineWidth)
1309 {
1310 //Not a CREATE or DESTROY function
1311 }
1312
1313 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
1314     VkCommandBuffer                             commandBuffer,
1315     float                                       depthBiasConstantFactor,
1316     float                                       depthBiasClamp,
1317     float                                       depthBiasSlopeFactor)
1318 {
1319 //Not a CREATE or DESTROY function
1320 }
1321
1322 static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
1323     VkCommandBuffer                             commandBuffer,
1324     const float                                 blendConstants[4])
1325 {
1326 //Not a CREATE or DESTROY function
1327 }
1328
1329 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
1330     VkCommandBuffer                             commandBuffer,
1331     float                                       minDepthBounds,
1332     float                                       maxDepthBounds)
1333 {
1334 //Not a CREATE or DESTROY function
1335 }
1336
1337 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
1338     VkCommandBuffer                             commandBuffer,
1339     VkStencilFaceFlags                          faceMask,
1340     uint32_t                                    compareMask)
1341 {
1342 //Not a CREATE or DESTROY function
1343 }
1344
1345 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
1346     VkCommandBuffer                             commandBuffer,
1347     VkStencilFaceFlags                          faceMask,
1348     uint32_t                                    writeMask)
1349 {
1350 //Not a CREATE or DESTROY function
1351 }
1352
1353 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
1354     VkCommandBuffer                             commandBuffer,
1355     VkStencilFaceFlags                          faceMask,
1356     uint32_t                                    reference)
1357 {
1358 //Not a CREATE or DESTROY function
1359 }
1360
1361 static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
1362     VkCommandBuffer                             commandBuffer,
1363     VkPipelineBindPoint                         pipelineBindPoint,
1364     VkPipelineLayout                            layout,
1365     uint32_t                                    firstSet,
1366     uint32_t                                    descriptorSetCount,
1367     const VkDescriptorSet*                      pDescriptorSets,
1368     uint32_t                                    dynamicOffsetCount,
1369     const uint32_t*                             pDynamicOffsets)
1370 {
1371 //Not a CREATE or DESTROY function
1372 }
1373
1374 static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
1375     VkCommandBuffer                             commandBuffer,
1376     VkBuffer                                    buffer,
1377     VkDeviceSize                                offset,
1378     VkIndexType                                 indexType)
1379 {
1380 //Not a CREATE or DESTROY function
1381 }
1382
1383 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
1384     VkCommandBuffer                             commandBuffer,
1385     uint32_t                                    firstBinding,
1386     uint32_t                                    bindingCount,
1387     const VkBuffer*                             pBuffers,
1388     const VkDeviceSize*                         pOffsets)
1389 {
1390 //Not a CREATE or DESTROY function
1391 }
1392
1393 static VKAPI_ATTR void VKAPI_CALL CmdDraw(
1394     VkCommandBuffer                             commandBuffer,
1395     uint32_t                                    vertexCount,
1396     uint32_t                                    instanceCount,
1397     uint32_t                                    firstVertex,
1398     uint32_t                                    firstInstance)
1399 {
1400 //Not a CREATE or DESTROY function
1401 }
1402
1403 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
1404     VkCommandBuffer                             commandBuffer,
1405     uint32_t                                    indexCount,
1406     uint32_t                                    instanceCount,
1407     uint32_t                                    firstIndex,
1408     int32_t                                     vertexOffset,
1409     uint32_t                                    firstInstance)
1410 {
1411 //Not a CREATE or DESTROY function
1412 }
1413
1414 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
1415     VkCommandBuffer                             commandBuffer,
1416     VkBuffer                                    buffer,
1417     VkDeviceSize                                offset,
1418     uint32_t                                    drawCount,
1419     uint32_t                                    stride)
1420 {
1421 //Not a CREATE or DESTROY function
1422 }
1423
1424 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
1425     VkCommandBuffer                             commandBuffer,
1426     VkBuffer                                    buffer,
1427     VkDeviceSize                                offset,
1428     uint32_t                                    drawCount,
1429     uint32_t                                    stride)
1430 {
1431 //Not a CREATE or DESTROY function
1432 }
1433
1434 static VKAPI_ATTR void VKAPI_CALL CmdDispatch(
1435     VkCommandBuffer                             commandBuffer,
1436     uint32_t                                    groupCountX,
1437     uint32_t                                    groupCountY,
1438     uint32_t                                    groupCountZ)
1439 {
1440 //Not a CREATE or DESTROY function
1441 }
1442
1443 static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
1444     VkCommandBuffer                             commandBuffer,
1445     VkBuffer                                    buffer,
1446     VkDeviceSize                                offset)
1447 {
1448 //Not a CREATE or DESTROY function
1449 }
1450
1451 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
1452     VkCommandBuffer                             commandBuffer,
1453     VkBuffer                                    srcBuffer,
1454     VkBuffer                                    dstBuffer,
1455     uint32_t                                    regionCount,
1456     const VkBufferCopy*                         pRegions)
1457 {
1458 //Not a CREATE or DESTROY function
1459 }
1460
1461 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
1462     VkCommandBuffer                             commandBuffer,
1463     VkImage                                     srcImage,
1464     VkImageLayout                               srcImageLayout,
1465     VkImage                                     dstImage,
1466     VkImageLayout                               dstImageLayout,
1467     uint32_t                                    regionCount,
1468     const VkImageCopy*                          pRegions)
1469 {
1470 //Not a CREATE or DESTROY function
1471 }
1472
1473 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
1474     VkCommandBuffer                             commandBuffer,
1475     VkImage                                     srcImage,
1476     VkImageLayout                               srcImageLayout,
1477     VkImage                                     dstImage,
1478     VkImageLayout                               dstImageLayout,
1479     uint32_t                                    regionCount,
1480     const VkImageBlit*                          pRegions,
1481     VkFilter                                    filter)
1482 {
1483 //Not a CREATE or DESTROY function
1484 }
1485
1486 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
1487     VkCommandBuffer                             commandBuffer,
1488     VkBuffer                                    srcBuffer,
1489     VkImage                                     dstImage,
1490     VkImageLayout                               dstImageLayout,
1491     uint32_t                                    regionCount,
1492     const VkBufferImageCopy*                    pRegions)
1493 {
1494 //Not a CREATE or DESTROY function
1495 }
1496
1497 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
1498     VkCommandBuffer                             commandBuffer,
1499     VkImage                                     srcImage,
1500     VkImageLayout                               srcImageLayout,
1501     VkBuffer                                    dstBuffer,
1502     uint32_t                                    regionCount,
1503     const VkBufferImageCopy*                    pRegions)
1504 {
1505 //Not a CREATE or DESTROY function
1506 }
1507
1508 static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
1509     VkCommandBuffer                             commandBuffer,
1510     VkBuffer                                    dstBuffer,
1511     VkDeviceSize                                dstOffset,
1512     VkDeviceSize                                dataSize,
1513     const void*                                 pData)
1514 {
1515 //Not a CREATE or DESTROY function
1516 }
1517
1518 static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
1519     VkCommandBuffer                             commandBuffer,
1520     VkBuffer                                    dstBuffer,
1521     VkDeviceSize                                dstOffset,
1522     VkDeviceSize                                size,
1523     uint32_t                                    data)
1524 {
1525 //Not a CREATE or DESTROY function
1526 }
1527
1528 static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
1529     VkCommandBuffer                             commandBuffer,
1530     VkImage                                     image,
1531     VkImageLayout                               imageLayout,
1532     const VkClearColorValue*                    pColor,
1533     uint32_t                                    rangeCount,
1534     const VkImageSubresourceRange*              pRanges)
1535 {
1536 //Not a CREATE or DESTROY function
1537 }
1538
1539 static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
1540     VkCommandBuffer                             commandBuffer,
1541     VkImage                                     image,
1542     VkImageLayout                               imageLayout,
1543     const VkClearDepthStencilValue*             pDepthStencil,
1544     uint32_t                                    rangeCount,
1545     const VkImageSubresourceRange*              pRanges)
1546 {
1547 //Not a CREATE or DESTROY function
1548 }
1549
1550 static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
1551     VkCommandBuffer                             commandBuffer,
1552     uint32_t                                    attachmentCount,
1553     const VkClearAttachment*                    pAttachments,
1554     uint32_t                                    rectCount,
1555     const VkClearRect*                          pRects)
1556 {
1557 //Not a CREATE or DESTROY function
1558 }
1559
1560 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
1561     VkCommandBuffer                             commandBuffer,
1562     VkImage                                     srcImage,
1563     VkImageLayout                               srcImageLayout,
1564     VkImage                                     dstImage,
1565     VkImageLayout                               dstImageLayout,
1566     uint32_t                                    regionCount,
1567     const VkImageResolve*                       pRegions)
1568 {
1569 //Not a CREATE or DESTROY function
1570 }
1571
1572 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
1573     VkCommandBuffer                             commandBuffer,
1574     VkEvent                                     event,
1575     VkPipelineStageFlags                        stageMask)
1576 {
1577 //Not a CREATE or DESTROY function
1578 }
1579
1580 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
1581     VkCommandBuffer                             commandBuffer,
1582     VkEvent                                     event,
1583     VkPipelineStageFlags                        stageMask)
1584 {
1585 //Not a CREATE or DESTROY function
1586 }
1587
1588 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
1589     VkCommandBuffer                             commandBuffer,
1590     uint32_t                                    eventCount,
1591     const VkEvent*                              pEvents,
1592     VkPipelineStageFlags                        srcStageMask,
1593     VkPipelineStageFlags                        dstStageMask,
1594     uint32_t                                    memoryBarrierCount,
1595     const VkMemoryBarrier*                      pMemoryBarriers,
1596     uint32_t                                    bufferMemoryBarrierCount,
1597     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
1598     uint32_t                                    imageMemoryBarrierCount,
1599     const VkImageMemoryBarrier*                 pImageMemoryBarriers)
1600 {
1601 //Not a CREATE or DESTROY function
1602 }
1603
1604 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
1605     VkCommandBuffer                             commandBuffer,
1606     VkPipelineStageFlags                        srcStageMask,
1607     VkPipelineStageFlags                        dstStageMask,
1608     VkDependencyFlags                           dependencyFlags,
1609     uint32_t                                    memoryBarrierCount,
1610     const VkMemoryBarrier*                      pMemoryBarriers,
1611     uint32_t                                    bufferMemoryBarrierCount,
1612     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
1613     uint32_t                                    imageMemoryBarrierCount,
1614     const VkImageMemoryBarrier*                 pImageMemoryBarriers)
1615 {
1616 //Not a CREATE or DESTROY function
1617 }
1618
1619 static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
1620     VkCommandBuffer                             commandBuffer,
1621     VkQueryPool                                 queryPool,
1622     uint32_t                                    query,
1623     VkQueryControlFlags                         flags)
1624 {
1625 //Not a CREATE or DESTROY function
1626 }
1627
1628 static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
1629     VkCommandBuffer                             commandBuffer,
1630     VkQueryPool                                 queryPool,
1631     uint32_t                                    query)
1632 {
1633 //Not a CREATE or DESTROY function
1634 }
1635
1636 static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
1637     VkCommandBuffer                             commandBuffer,
1638     VkQueryPool                                 queryPool,
1639     uint32_t                                    firstQuery,
1640     uint32_t                                    queryCount)
1641 {
1642 //Not a CREATE or DESTROY function
1643 }
1644
1645 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
1646     VkCommandBuffer                             commandBuffer,
1647     VkPipelineStageFlagBits                     pipelineStage,
1648     VkQueryPool                                 queryPool,
1649     uint32_t                                    query)
1650 {
1651 //Not a CREATE or DESTROY function
1652 }
1653
1654 static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
1655     VkCommandBuffer                             commandBuffer,
1656     VkQueryPool                                 queryPool,
1657     uint32_t                                    firstQuery,
1658     uint32_t                                    queryCount,
1659     VkBuffer                                    dstBuffer,
1660     VkDeviceSize                                dstOffset,
1661     VkDeviceSize                                stride,
1662     VkQueryResultFlags                          flags)
1663 {
1664 //Not a CREATE or DESTROY function
1665 }
1666
1667 static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
1668     VkCommandBuffer                             commandBuffer,
1669     VkPipelineLayout                            layout,
1670     VkShaderStageFlags                          stageFlags,
1671     uint32_t                                    offset,
1672     uint32_t                                    size,
1673     const void*                                 pValues)
1674 {
1675 //Not a CREATE or DESTROY function
1676 }
1677
1678 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
1679     VkCommandBuffer                             commandBuffer,
1680     const VkRenderPassBeginInfo*                pRenderPassBegin,
1681     VkSubpassContents                           contents)
1682 {
1683 //Not a CREATE or DESTROY function
1684 }
1685
1686 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
1687     VkCommandBuffer                             commandBuffer,
1688     VkSubpassContents                           contents)
1689 {
1690 //Not a CREATE or DESTROY function
1691 }
1692
1693 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
1694     VkCommandBuffer                             commandBuffer)
1695 {
1696 //Not a CREATE or DESTROY function
1697 }
1698
1699 static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
1700     VkCommandBuffer                             commandBuffer,
1701     uint32_t                                    commandBufferCount,
1702     const VkCommandBuffer*                      pCommandBuffers)
1703 {
1704 //Not a CREATE or DESTROY function
1705 }
1706
1707
1708 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(
1709     uint32_t*                                   pApiVersion)
1710 {
1711
1712     *pApiVersion = kSupportedVulkanAPIVersion;
1713     return VK_SUCCESS;
1714 }
1715
1716 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
1717     VkDevice                                    device,
1718     uint32_t                                    bindInfoCount,
1719     const VkBindBufferMemoryInfo*               pBindInfos)
1720 {
1721 //Not a CREATE or DESTROY function
1722     return VK_SUCCESS;
1723 }
1724
1725 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
1726     VkDevice                                    device,
1727     uint32_t                                    bindInfoCount,
1728     const VkBindImageMemoryInfo*                pBindInfos)
1729 {
1730 //Not a CREATE or DESTROY function
1731     return VK_SUCCESS;
1732 }
1733
1734 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
1735     VkDevice                                    device,
1736     uint32_t                                    heapIndex,
1737     uint32_t                                    localDeviceIndex,
1738     uint32_t                                    remoteDeviceIndex,
1739     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures)
1740 {
1741 //Not a CREATE or DESTROY function
1742 }
1743
1744 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
1745     VkCommandBuffer                             commandBuffer,
1746     uint32_t                                    deviceMask)
1747 {
1748 //Not a CREATE or DESTROY function
1749 }
1750
1751 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
1752     VkCommandBuffer                             commandBuffer,
1753     uint32_t                                    baseGroupX,
1754     uint32_t                                    baseGroupY,
1755     uint32_t                                    baseGroupZ,
1756     uint32_t                                    groupCountX,
1757     uint32_t                                    groupCountY,
1758     uint32_t                                    groupCountZ)
1759 {
1760 //Not a CREATE or DESTROY function
1761 }
1762
1763 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
1764     VkInstance                                  instance,
1765     uint32_t*                                   pPhysicalDeviceGroupCount,
1766     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties)
1767 {
1768 //Not a CREATE or DESTROY function
1769     return VK_SUCCESS;
1770 }
1771
1772 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
1773     VkDevice                                    device,
1774     const VkImageMemoryRequirementsInfo2*       pInfo,
1775     VkMemoryRequirements2*                      pMemoryRequirements)
1776 {
1777     GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1778 }
1779
1780 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
1781     VkDevice                                    device,
1782     const VkBufferMemoryRequirementsInfo2*      pInfo,
1783     VkMemoryRequirements2*                      pMemoryRequirements)
1784 {
1785     GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1786 }
1787
1788 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
1789     VkDevice                                    device,
1790     const VkImageSparseMemoryRequirementsInfo2* pInfo,
1791     uint32_t*                                   pSparseMemoryRequirementCount,
1792     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
1793 {
1794 //Not a CREATE or DESTROY function
1795 }
1796
1797 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
1798     VkPhysicalDevice                            physicalDevice,
1799     VkPhysicalDeviceFeatures2*                  pFeatures)
1800 {
1801     GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
1802 }
1803
1804 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
1805     VkPhysicalDevice                            physicalDevice,
1806     VkPhysicalDeviceProperties2*                pProperties)
1807 {
1808     GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
1809 }
1810
1811 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
1812     VkPhysicalDevice                            physicalDevice,
1813     VkFormat                                    format,
1814     VkFormatProperties2*                        pFormatProperties)
1815 {
1816     GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
1817 }
1818
1819 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
1820     VkPhysicalDevice                            physicalDevice,
1821     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
1822     VkImageFormatProperties2*                   pImageFormatProperties)
1823 {
1824     return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
1825 }
1826
1827 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
1828     VkPhysicalDevice                            physicalDevice,
1829     uint32_t*                                   pQueueFamilyPropertyCount,
1830     VkQueueFamilyProperties2*                   pQueueFamilyProperties)
1831 {
1832     GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1833 }
1834
1835 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
1836     VkPhysicalDevice                            physicalDevice,
1837     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties)
1838 {
1839     GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
1840 }
1841
1842 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
1843     VkPhysicalDevice                            physicalDevice,
1844     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1845     uint32_t*                                   pPropertyCount,
1846     VkSparseImageFormatProperties2*             pProperties)
1847 {
1848 //Not a CREATE or DESTROY function
1849 }
1850
1851 static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
1852     VkDevice                                    device,
1853     VkCommandPool                               commandPool,
1854     VkCommandPoolTrimFlags                      flags)
1855 {
1856 //Not a CREATE or DESTROY function
1857 }
1858
1859 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
1860     VkDevice                                    device,
1861     const VkDeviceQueueInfo2*                   pQueueInfo,
1862     VkQueue*                                    pQueue)
1863 {
1864     GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
1865     // TODO: Add further support for GetDeviceQueue2 features
1866 }
1867
1868 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
1869     VkDevice                                    device,
1870     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
1871     const VkAllocationCallbacks*                pAllocator,
1872     VkSamplerYcbcrConversion*                   pYcbcrConversion)
1873 {
1874     unique_lock_t lock(global_lock);
1875     *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
1876     return VK_SUCCESS;
1877 }
1878
1879 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
1880     VkDevice                                    device,
1881     VkSamplerYcbcrConversion                    ycbcrConversion,
1882     const VkAllocationCallbacks*                pAllocator)
1883 {
1884 //Destroy object
1885 }
1886
1887 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
1888     VkDevice                                    device,
1889     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1890     const VkAllocationCallbacks*                pAllocator,
1891     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate)
1892 {
1893     unique_lock_t lock(global_lock);
1894     *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
1895     return VK_SUCCESS;
1896 }
1897
1898 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
1899     VkDevice                                    device,
1900     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1901     const VkAllocationCallbacks*                pAllocator)
1902 {
1903 //Destroy object
1904 }
1905
1906 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
1907     VkDevice                                    device,
1908     VkDescriptorSet                             descriptorSet,
1909     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1910     const void*                                 pData)
1911 {
1912 //Not a CREATE or DESTROY function
1913 }
1914
1915 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
1916     VkPhysicalDevice                            physicalDevice,
1917     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
1918     VkExternalBufferProperties*                 pExternalBufferProperties)
1919 {
1920     // Hard-code support for all handle types and features
1921     pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7;
1922     pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0x1FF;
1923     pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = 0x1FF;
1924 }
1925
1926 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
1927     VkPhysicalDevice                            physicalDevice,
1928     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
1929     VkExternalFenceProperties*                  pExternalFenceProperties)
1930 {
1931     // Hard-code support for all handle types and features
1932     pExternalFenceProperties->exportFromImportedHandleTypes = 0xF;
1933     pExternalFenceProperties->compatibleHandleTypes = 0xF;
1934     pExternalFenceProperties->externalFenceFeatures = 0x3;
1935 }
1936
1937 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
1938     VkPhysicalDevice                            physicalDevice,
1939     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1940     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties)
1941 {
1942     // Hard code support for all handle types and features
1943     pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F;
1944     pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F;
1945     pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3;
1946 }
1947
1948 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
1949     VkDevice                                    device,
1950     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1951     VkDescriptorSetLayoutSupport*               pSupport)
1952 {
1953 //Not a CREATE or DESTROY function
1954 }
1955
1956
1957 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
1958     VkCommandBuffer                             commandBuffer,
1959     VkBuffer                                    buffer,
1960     VkDeviceSize                                offset,
1961     VkBuffer                                    countBuffer,
1962     VkDeviceSize                                countBufferOffset,
1963     uint32_t                                    maxDrawCount,
1964     uint32_t                                    stride)
1965 {
1966 //Not a CREATE or DESTROY function
1967 }
1968
1969 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
1970     VkCommandBuffer                             commandBuffer,
1971     VkBuffer                                    buffer,
1972     VkDeviceSize                                offset,
1973     VkBuffer                                    countBuffer,
1974     VkDeviceSize                                countBufferOffset,
1975     uint32_t                                    maxDrawCount,
1976     uint32_t                                    stride)
1977 {
1978 //Not a CREATE or DESTROY function
1979 }
1980
1981 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
1982     VkDevice                                    device,
1983     const VkRenderPassCreateInfo2*              pCreateInfo,
1984     const VkAllocationCallbacks*                pAllocator,
1985     VkRenderPass*                               pRenderPass)
1986 {
1987     unique_lock_t lock(global_lock);
1988     *pRenderPass = (VkRenderPass)global_unique_handle++;
1989     return VK_SUCCESS;
1990 }
1991
1992 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
1993     VkCommandBuffer                             commandBuffer,
1994     const VkRenderPassBeginInfo*                pRenderPassBegin,
1995     const VkSubpassBeginInfo*                   pSubpassBeginInfo)
1996 {
1997 //Not a CREATE or DESTROY function
1998 }
1999
2000 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
2001     VkCommandBuffer                             commandBuffer,
2002     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
2003     const VkSubpassEndInfo*                     pSubpassEndInfo)
2004 {
2005 //Not a CREATE or DESTROY function
2006 }
2007
2008 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
2009     VkCommandBuffer                             commandBuffer,
2010     const VkSubpassEndInfo*                     pSubpassEndInfo)
2011 {
2012 //Not a CREATE or DESTROY function
2013 }
2014
2015 static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
2016     VkDevice                                    device,
2017     VkQueryPool                                 queryPool,
2018     uint32_t                                    firstQuery,
2019     uint32_t                                    queryCount)
2020 {
2021 //Not a CREATE or DESTROY function
2022 }
2023
2024 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
2025     VkDevice                                    device,
2026     VkSemaphore                                 semaphore,
2027     uint64_t*                                   pValue)
2028 {
2029 //Not a CREATE or DESTROY function
2030     return VK_SUCCESS;
2031 }
2032
2033 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
2034     VkDevice                                    device,
2035     const VkSemaphoreWaitInfo*                  pWaitInfo,
2036     uint64_t                                    timeout)
2037 {
2038 //Not a CREATE or DESTROY function
2039     return VK_SUCCESS;
2040 }
2041
2042 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
2043     VkDevice                                    device,
2044     const VkSemaphoreSignalInfo*                pSignalInfo)
2045 {
2046 //Not a CREATE or DESTROY function
2047     return VK_SUCCESS;
2048 }
2049
2050 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
2051     VkDevice                                    device,
2052     const VkBufferDeviceAddressInfo*            pInfo)
2053 {
2054 //Not a CREATE or DESTROY function
2055     return VK_SUCCESS;
2056 }
2057
2058 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
2059     VkDevice                                    device,
2060     const VkBufferDeviceAddressInfo*            pInfo)
2061 {
2062 //Not a CREATE or DESTROY function
2063     return VK_SUCCESS;
2064 }
2065
2066 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
2067     VkDevice                                    device,
2068     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
2069 {
2070 //Not a CREATE or DESTROY function
2071     return VK_SUCCESS;
2072 }
2073
2074
2075 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(
2076     VkPhysicalDevice                            physicalDevice,
2077     uint32_t*                                   pToolCount,
2078     VkPhysicalDeviceToolProperties*             pToolProperties)
2079 {
2080 //Not a CREATE or DESTROY function
2081     return VK_SUCCESS;
2082 }
2083
2084 static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(
2085     VkDevice                                    device,
2086     const VkPrivateDataSlotCreateInfo*          pCreateInfo,
2087     const VkAllocationCallbacks*                pAllocator,
2088     VkPrivateDataSlot*                          pPrivateDataSlot)
2089 {
2090     unique_lock_t lock(global_lock);
2091     *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++;
2092     return VK_SUCCESS;
2093 }
2094
2095 static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(
2096     VkDevice                                    device,
2097     VkPrivateDataSlot                           privateDataSlot,
2098     const VkAllocationCallbacks*                pAllocator)
2099 {
2100 //Destroy object
2101 }
2102
2103 static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(
2104     VkDevice                                    device,
2105     VkObjectType                                objectType,
2106     uint64_t                                    objectHandle,
2107     VkPrivateDataSlot                           privateDataSlot,
2108     uint64_t                                    data)
2109 {
2110 //Not a CREATE or DESTROY function
2111     return VK_SUCCESS;
2112 }
2113
2114 static VKAPI_ATTR void VKAPI_CALL GetPrivateData(
2115     VkDevice                                    device,
2116     VkObjectType                                objectType,
2117     uint64_t                                    objectHandle,
2118     VkPrivateDataSlot                           privateDataSlot,
2119     uint64_t*                                   pData)
2120 {
2121 //Not a CREATE or DESTROY function
2122 }
2123
2124 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(
2125     VkCommandBuffer                             commandBuffer,
2126     VkEvent                                     event,
2127     const VkDependencyInfo*                     pDependencyInfo)
2128 {
2129 //Not a CREATE or DESTROY function
2130 }
2131
2132 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(
2133     VkCommandBuffer                             commandBuffer,
2134     VkEvent                                     event,
2135     VkPipelineStageFlags2                       stageMask)
2136 {
2137 //Not a CREATE or DESTROY function
2138 }
2139
2140 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(
2141     VkCommandBuffer                             commandBuffer,
2142     uint32_t                                    eventCount,
2143     const VkEvent*                              pEvents,
2144     const VkDependencyInfo*                     pDependencyInfos)
2145 {
2146 //Not a CREATE or DESTROY function
2147 }
2148
2149 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(
2150     VkCommandBuffer                             commandBuffer,
2151     const VkDependencyInfo*                     pDependencyInfo)
2152 {
2153 //Not a CREATE or DESTROY function
2154 }
2155
2156 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(
2157     VkCommandBuffer                             commandBuffer,
2158     VkPipelineStageFlags2                       stage,
2159     VkQueryPool                                 queryPool,
2160     uint32_t                                    query)
2161 {
2162 //Not a CREATE or DESTROY function
2163 }
2164
2165 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(
2166     VkQueue                                     queue,
2167     uint32_t                                    submitCount,
2168     const VkSubmitInfo2*                        pSubmits,
2169     VkFence                                     fence)
2170 {
2171 //Not a CREATE or DESTROY function
2172     return VK_SUCCESS;
2173 }
2174
2175 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(
2176     VkCommandBuffer                             commandBuffer,
2177     const VkCopyBufferInfo2*                    pCopyBufferInfo)
2178 {
2179 //Not a CREATE or DESTROY function
2180 }
2181
2182 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(
2183     VkCommandBuffer                             commandBuffer,
2184     const VkCopyImageInfo2*                     pCopyImageInfo)
2185 {
2186 //Not a CREATE or DESTROY function
2187 }
2188
2189 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(
2190     VkCommandBuffer                             commandBuffer,
2191     const VkCopyBufferToImageInfo2*             pCopyBufferToImageInfo)
2192 {
2193 //Not a CREATE or DESTROY function
2194 }
2195
2196 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(
2197     VkCommandBuffer                             commandBuffer,
2198     const VkCopyImageToBufferInfo2*             pCopyImageToBufferInfo)
2199 {
2200 //Not a CREATE or DESTROY function
2201 }
2202
2203 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(
2204     VkCommandBuffer                             commandBuffer,
2205     const VkBlitImageInfo2*                     pBlitImageInfo)
2206 {
2207 //Not a CREATE or DESTROY function
2208 }
2209
2210 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(
2211     VkCommandBuffer                             commandBuffer,
2212     const VkResolveImageInfo2*                  pResolveImageInfo)
2213 {
2214 //Not a CREATE or DESTROY function
2215 }
2216
2217 static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(
2218     VkCommandBuffer                             commandBuffer,
2219     const VkRenderingInfo*                      pRenderingInfo)
2220 {
2221 //Not a CREATE or DESTROY function
2222 }
2223
2224 static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(
2225     VkCommandBuffer                             commandBuffer)
2226 {
2227 //Not a CREATE or DESTROY function
2228 }
2229
2230 static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(
2231     VkCommandBuffer                             commandBuffer,
2232     VkCullModeFlags                             cullMode)
2233 {
2234 //Not a CREATE or DESTROY function
2235 }
2236
2237 static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(
2238     VkCommandBuffer                             commandBuffer,
2239     VkFrontFace                                 frontFace)
2240 {
2241 //Not a CREATE or DESTROY function
2242 }
2243
2244 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(
2245     VkCommandBuffer                             commandBuffer,
2246     VkPrimitiveTopology                         primitiveTopology)
2247 {
2248 //Not a CREATE or DESTROY function
2249 }
2250
2251 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(
2252     VkCommandBuffer                             commandBuffer,
2253     uint32_t                                    viewportCount,
2254     const VkViewport*                           pViewports)
2255 {
2256 //Not a CREATE or DESTROY function
2257 }
2258
2259 static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(
2260     VkCommandBuffer                             commandBuffer,
2261     uint32_t                                    scissorCount,
2262     const VkRect2D*                             pScissors)
2263 {
2264 //Not a CREATE or DESTROY function
2265 }
2266
2267 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(
2268     VkCommandBuffer                             commandBuffer,
2269     uint32_t                                    firstBinding,
2270     uint32_t                                    bindingCount,
2271     const VkBuffer*                             pBuffers,
2272     const VkDeviceSize*                         pOffsets,
2273     const VkDeviceSize*                         pSizes,
2274     const VkDeviceSize*                         pStrides)
2275 {
2276 //Not a CREATE or DESTROY function
2277 }
2278
2279 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(
2280     VkCommandBuffer                             commandBuffer,
2281     VkBool32                                    depthTestEnable)
2282 {
2283 //Not a CREATE or DESTROY function
2284 }
2285
2286 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(
2287     VkCommandBuffer                             commandBuffer,
2288     VkBool32                                    depthWriteEnable)
2289 {
2290 //Not a CREATE or DESTROY function
2291 }
2292
2293 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(
2294     VkCommandBuffer                             commandBuffer,
2295     VkCompareOp                                 depthCompareOp)
2296 {
2297 //Not a CREATE or DESTROY function
2298 }
2299
2300 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(
2301     VkCommandBuffer                             commandBuffer,
2302     VkBool32                                    depthBoundsTestEnable)
2303 {
2304 //Not a CREATE or DESTROY function
2305 }
2306
2307 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(
2308     VkCommandBuffer                             commandBuffer,
2309     VkBool32                                    stencilTestEnable)
2310 {
2311 //Not a CREATE or DESTROY function
2312 }
2313
2314 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(
2315     VkCommandBuffer                             commandBuffer,
2316     VkStencilFaceFlags                          faceMask,
2317     VkStencilOp                                 failOp,
2318     VkStencilOp                                 passOp,
2319     VkStencilOp                                 depthFailOp,
2320     VkCompareOp                                 compareOp)
2321 {
2322 //Not a CREATE or DESTROY function
2323 }
2324
2325 static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(
2326     VkCommandBuffer                             commandBuffer,
2327     VkBool32                                    rasterizerDiscardEnable)
2328 {
2329 //Not a CREATE or DESTROY function
2330 }
2331
2332 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(
2333     VkCommandBuffer                             commandBuffer,
2334     VkBool32                                    depthBiasEnable)
2335 {
2336 //Not a CREATE or DESTROY function
2337 }
2338
2339 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(
2340     VkCommandBuffer                             commandBuffer,
2341     VkBool32                                    primitiveRestartEnable)
2342 {
2343 //Not a CREATE or DESTROY function
2344 }
2345
2346 static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(
2347     VkDevice                                    device,
2348     const VkDeviceBufferMemoryRequirements*     pInfo,
2349     VkMemoryRequirements2*                      pMemoryRequirements)
2350 {
2351 //Not a CREATE or DESTROY function
2352 }
2353
2354 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(
2355     VkDevice                                    device,
2356     const VkDeviceImageMemoryRequirements*      pInfo,
2357     VkMemoryRequirements2*                      pMemoryRequirements)
2358 {
2359 //Not a CREATE or DESTROY function
2360 }
2361
2362 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements(
2363     VkDevice                                    device,
2364     const VkDeviceImageMemoryRequirements*      pInfo,
2365     uint32_t*                                   pSparseMemoryRequirementCount,
2366     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
2367 {
2368 //Not a CREATE or DESTROY function
2369 }
2370
2371
2372 static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
2373     VkInstance                                  instance,
2374     VkSurfaceKHR                                surface,
2375     const VkAllocationCallbacks*                pAllocator)
2376 {
2377 //Destroy object
2378 }
2379
2380 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
2381     VkPhysicalDevice                            physicalDevice,
2382     uint32_t                                    queueFamilyIndex,
2383     VkSurfaceKHR                                surface,
2384     VkBool32*                                   pSupported)
2385 {
2386     // Currently say that all surface/queue combos are supported
2387     *pSupported = VK_TRUE;
2388     return VK_SUCCESS;
2389 }
2390
2391 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
2392     VkPhysicalDevice                            physicalDevice,
2393     VkSurfaceKHR                                surface,
2394     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities)
2395 {
2396     // In general just say max supported is available for requested surface
2397     pSurfaceCapabilities->minImageCount = 1;
2398     pSurfaceCapabilities->maxImageCount = 0;
2399     pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF;
2400     pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF;
2401     pSurfaceCapabilities->minImageExtent.width = 1;
2402     pSurfaceCapabilities->minImageExtent.height = 1;
2403     pSurfaceCapabilities->maxImageExtent.width = 0xFFFF;
2404     pSurfaceCapabilities->maxImageExtent.height = 0xFFFF;
2405     pSurfaceCapabilities->maxImageArrayLayers = 128;
2406     pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
2407                                                 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
2408                                                 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
2409                                                 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
2410                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
2411                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
2412                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
2413                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
2414                                                 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
2415     pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
2416     pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
2417                                                     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR |
2418                                                     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR |
2419                                                     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
2420     pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2421                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
2422                                                 VK_IMAGE_USAGE_SAMPLED_BIT |
2423                                                 VK_IMAGE_USAGE_STORAGE_BIT |
2424                                                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
2425                                                 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
2426                                                 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
2427                                                 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
2428     return VK_SUCCESS;
2429 }
2430
2431 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
2432     VkPhysicalDevice                            physicalDevice,
2433     VkSurfaceKHR                                surface,
2434     uint32_t*                                   pSurfaceFormatCount,
2435     VkSurfaceFormatKHR*                         pSurfaceFormats)
2436 {
2437     // Currently always say that RGBA8 & BGRA8 are supported
2438     if (!pSurfaceFormats) {
2439         *pSurfaceFormatCount = 2;
2440     } else {
2441         // Intentionally falling through and just filling however many types are requested
2442         switch(*pSurfaceFormatCount) {
2443         case 2:
2444             pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM;
2445             pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2446             // fall through
2447         default:
2448             pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM;
2449             pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2450             break;
2451         }
2452     }
2453     return VK_SUCCESS;
2454 }
2455
2456 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
2457     VkPhysicalDevice                            physicalDevice,
2458     VkSurfaceKHR                                surface,
2459     uint32_t*                                   pPresentModeCount,
2460     VkPresentModeKHR*                           pPresentModes)
2461 {
2462     // Currently always say that all present modes are supported
2463     if (!pPresentModes) {
2464         *pPresentModeCount = 6;
2465     } else {
2466         // Intentionally falling through and just filling however many modes are requested
2467         switch(*pPresentModeCount) {
2468         case 6:
2469             pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
2470             // fall through
2471         case 5:
2472             pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
2473             // fall through
2474         case 4:
2475             pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
2476             // fall through
2477         case 3:
2478             pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR;
2479             // fall through
2480         case 2:
2481             pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR;
2482             // fall through
2483         default:
2484             pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
2485             break;
2486         }
2487     }
2488     return VK_SUCCESS;
2489 }
2490
2491
2492 static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
2493     VkDevice                                    device,
2494     const VkSwapchainCreateInfoKHR*             pCreateInfo,
2495     const VkAllocationCallbacks*                pAllocator,
2496     VkSwapchainKHR*                             pSwapchain)
2497 {
2498     unique_lock_t lock(global_lock);
2499     *pSwapchain = (VkSwapchainKHR)global_unique_handle++;
2500     for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){
2501         swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++;
2502     }
2503     return VK_SUCCESS;
2504 }
2505
2506 static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
2507     VkDevice                                    device,
2508     VkSwapchainKHR                              swapchain,
2509     const VkAllocationCallbacks*                pAllocator)
2510 {
2511     unique_lock_t lock(global_lock);
2512     swapchain_image_map.clear();
2513 }
2514
2515 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
2516     VkDevice                                    device,
2517     VkSwapchainKHR                              swapchain,
2518     uint32_t*                                   pSwapchainImageCount,
2519     VkImage*                                    pSwapchainImages)
2520 {
2521     if (!pSwapchainImages) {
2522         *pSwapchainImageCount = icd_swapchain_image_count;
2523     } else {
2524         unique_lock_t lock(global_lock);
2525         for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){
2526             pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i];
2527         }
2528
2529         if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE;
2530         else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count;
2531     }
2532     return VK_SUCCESS;
2533 }
2534
2535 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
2536     VkDevice                                    device,
2537     VkSwapchainKHR                              swapchain,
2538     uint64_t                                    timeout,
2539     VkSemaphore                                 semaphore,
2540     VkFence                                     fence,
2541     uint32_t*                                   pImageIndex)
2542 {
2543     *pImageIndex = 0;
2544     return VK_SUCCESS;
2545 }
2546
2547 static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
2548     VkQueue                                     queue,
2549     const VkPresentInfoKHR*                     pPresentInfo)
2550 {
2551 //Not a CREATE or DESTROY function
2552     return VK_SUCCESS;
2553 }
2554
2555 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
2556     VkDevice                                    device,
2557     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities)
2558 {
2559 //Not a CREATE or DESTROY function
2560     return VK_SUCCESS;
2561 }
2562
2563 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
2564     VkDevice                                    device,
2565     VkSurfaceKHR                                surface,
2566     VkDeviceGroupPresentModeFlagsKHR*           pModes)
2567 {
2568 //Not a CREATE or DESTROY function
2569     return VK_SUCCESS;
2570 }
2571
2572 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
2573     VkPhysicalDevice                            physicalDevice,
2574     VkSurfaceKHR                                surface,
2575     uint32_t*                                   pRectCount,
2576     VkRect2D*                                   pRects)
2577 {
2578 //Not a CREATE or DESTROY function
2579     return VK_SUCCESS;
2580 }
2581
2582 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
2583     VkDevice                                    device,
2584     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
2585     uint32_t*                                   pImageIndex)
2586 {
2587     *pImageIndex = 0;
2588     return VK_SUCCESS;
2589 }
2590
2591
2592 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
2593     VkPhysicalDevice                            physicalDevice,
2594     uint32_t*                                   pPropertyCount,
2595     VkDisplayPropertiesKHR*                     pProperties)
2596 {
2597 //Not a CREATE or DESTROY function
2598     return VK_SUCCESS;
2599 }
2600
2601 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
2602     VkPhysicalDevice                            physicalDevice,
2603     uint32_t*                                   pPropertyCount,
2604     VkDisplayPlanePropertiesKHR*                pProperties)
2605 {
2606 //Not a CREATE or DESTROY function
2607     return VK_SUCCESS;
2608 }
2609
2610 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
2611     VkPhysicalDevice                            physicalDevice,
2612     uint32_t                                    planeIndex,
2613     uint32_t*                                   pDisplayCount,
2614     VkDisplayKHR*                               pDisplays)
2615 {
2616 //Not a CREATE or DESTROY function
2617     return VK_SUCCESS;
2618 }
2619
2620 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
2621     VkPhysicalDevice                            physicalDevice,
2622     VkDisplayKHR                                display,
2623     uint32_t*                                   pPropertyCount,
2624     VkDisplayModePropertiesKHR*                 pProperties)
2625 {
2626 //Not a CREATE or DESTROY function
2627     return VK_SUCCESS;
2628 }
2629
2630 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
2631     VkPhysicalDevice                            physicalDevice,
2632     VkDisplayKHR                                display,
2633     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
2634     const VkAllocationCallbacks*                pAllocator,
2635     VkDisplayModeKHR*                           pMode)
2636 {
2637     unique_lock_t lock(global_lock);
2638     *pMode = (VkDisplayModeKHR)global_unique_handle++;
2639     return VK_SUCCESS;
2640 }
2641
2642 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
2643     VkPhysicalDevice                            physicalDevice,
2644     VkDisplayModeKHR                            mode,
2645     uint32_t                                    planeIndex,
2646     VkDisplayPlaneCapabilitiesKHR*              pCapabilities)
2647 {
2648 //Not a CREATE or DESTROY function
2649     return VK_SUCCESS;
2650 }
2651
2652 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
2653     VkInstance                                  instance,
2654     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
2655     const VkAllocationCallbacks*                pAllocator,
2656     VkSurfaceKHR*                               pSurface)
2657 {
2658     unique_lock_t lock(global_lock);
2659     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2660     return VK_SUCCESS;
2661 }
2662
2663
2664 static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
2665     VkDevice                                    device,
2666     uint32_t                                    swapchainCount,
2667     const VkSwapchainCreateInfoKHR*             pCreateInfos,
2668     const VkAllocationCallbacks*                pAllocator,
2669     VkSwapchainKHR*                             pSwapchains)
2670 {
2671     unique_lock_t lock(global_lock);
2672     for (uint32_t i = 0; i < swapchainCount; ++i) {
2673         pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++;
2674     }
2675     return VK_SUCCESS;
2676 }
2677
2678 #ifdef VK_USE_PLATFORM_XLIB_KHR
2679
2680 static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
2681     VkInstance                                  instance,
2682     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
2683     const VkAllocationCallbacks*                pAllocator,
2684     VkSurfaceKHR*                               pSurface)
2685 {
2686     unique_lock_t lock(global_lock);
2687     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2688     return VK_SUCCESS;
2689 }
2690
2691 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
2692     VkPhysicalDevice                            physicalDevice,
2693     uint32_t                                    queueFamilyIndex,
2694     Display*                                    dpy,
2695     VisualID                                    visualID)
2696 {
2697 //Not a CREATE or DESTROY function
2698     return VK_SUCCESS;
2699 }
2700 #endif /* VK_USE_PLATFORM_XLIB_KHR */
2701
2702 #ifdef VK_USE_PLATFORM_XCB_KHR
2703
2704 static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
2705     VkInstance                                  instance,
2706     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
2707     const VkAllocationCallbacks*                pAllocator,
2708     VkSurfaceKHR*                               pSurface)
2709 {
2710     unique_lock_t lock(global_lock);
2711     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2712     return VK_SUCCESS;
2713 }
2714
2715 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
2716     VkPhysicalDevice                            physicalDevice,
2717     uint32_t                                    queueFamilyIndex,
2718     xcb_connection_t*                           connection,
2719     xcb_visualid_t                              visual_id)
2720 {
2721 //Not a CREATE or DESTROY function
2722     return VK_SUCCESS;
2723 }
2724 #endif /* VK_USE_PLATFORM_XCB_KHR */
2725
2726 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
2727
2728 static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
2729     VkInstance                                  instance,
2730     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
2731     const VkAllocationCallbacks*                pAllocator,
2732     VkSurfaceKHR*                               pSurface)
2733 {
2734     unique_lock_t lock(global_lock);
2735     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2736     return VK_SUCCESS;
2737 }
2738
2739 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
2740     VkPhysicalDevice                            physicalDevice,
2741     uint32_t                                    queueFamilyIndex,
2742     struct wl_display*                          display)
2743 {
2744 //Not a CREATE or DESTROY function
2745     return VK_SUCCESS;
2746 }
2747 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
2748
2749 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2750
2751 static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
2752     VkInstance                                  instance,
2753     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
2754     const VkAllocationCallbacks*                pAllocator,
2755     VkSurfaceKHR*                               pSurface)
2756 {
2757     unique_lock_t lock(global_lock);
2758     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2759     return VK_SUCCESS;
2760 }
2761 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
2762
2763 #ifdef VK_USE_PLATFORM_WIN32_KHR
2764
2765 static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
2766     VkInstance                                  instance,
2767     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
2768     const VkAllocationCallbacks*                pAllocator,
2769     VkSurfaceKHR*                               pSurface)
2770 {
2771     unique_lock_t lock(global_lock);
2772     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2773     return VK_SUCCESS;
2774 }
2775
2776 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
2777     VkPhysicalDevice                            physicalDevice,
2778     uint32_t                                    queueFamilyIndex)
2779 {
2780 //Not a CREATE or DESTROY function
2781     return VK_SUCCESS;
2782 }
2783 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2784
2785
2786 #ifdef VK_ENABLE_BETA_EXTENSIONS
2787
2788 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(
2789     VkPhysicalDevice                            physicalDevice,
2790     const VkVideoProfileKHR*                    pVideoProfile,
2791     VkVideoCapabilitiesKHR*                     pCapabilities)
2792 {
2793 //Not a CREATE or DESTROY function
2794     return VK_SUCCESS;
2795 }
2796
2797 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR(
2798     VkPhysicalDevice                            physicalDevice,
2799     const VkPhysicalDeviceVideoFormatInfoKHR*   pVideoFormatInfo,
2800     uint32_t*                                   pVideoFormatPropertyCount,
2801     VkVideoFormatPropertiesKHR*                 pVideoFormatProperties)
2802 {
2803 //Not a CREATE or DESTROY function
2804     return VK_SUCCESS;
2805 }
2806
2807 static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(
2808     VkDevice                                    device,
2809     const VkVideoSessionCreateInfoKHR*          pCreateInfo,
2810     const VkAllocationCallbacks*                pAllocator,
2811     VkVideoSessionKHR*                          pVideoSession)
2812 {
2813     unique_lock_t lock(global_lock);
2814     *pVideoSession = (VkVideoSessionKHR)global_unique_handle++;
2815     return VK_SUCCESS;
2816 }
2817
2818 static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(
2819     VkDevice                                    device,
2820     VkVideoSessionKHR                           videoSession,
2821     const VkAllocationCallbacks*                pAllocator)
2822 {
2823 //Destroy object
2824 }
2825
2826 static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR(
2827     VkDevice                                    device,
2828     VkVideoSessionKHR                           videoSession,
2829     uint32_t*                                   pVideoSessionMemoryRequirementsCount,
2830     VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements)
2831 {
2832 //Not a CREATE or DESTROY function
2833     return VK_SUCCESS;
2834 }
2835
2836 static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(
2837     VkDevice                                    device,
2838     VkVideoSessionKHR                           videoSession,
2839     uint32_t                                    videoSessionBindMemoryCount,
2840     const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories)
2841 {
2842 //Not a CREATE or DESTROY function
2843     return VK_SUCCESS;
2844 }
2845
2846 static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(
2847     VkDevice                                    device,
2848     const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
2849     const VkAllocationCallbacks*                pAllocator,
2850     VkVideoSessionParametersKHR*                pVideoSessionParameters)
2851 {
2852     unique_lock_t lock(global_lock);
2853     *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++;
2854     return VK_SUCCESS;
2855 }
2856
2857 static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(
2858     VkDevice                                    device,
2859     VkVideoSessionParametersKHR                 videoSessionParameters,
2860     const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
2861 {
2862 //Not a CREATE or DESTROY function
2863     return VK_SUCCESS;
2864 }
2865
2866 static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(
2867     VkDevice                                    device,
2868     VkVideoSessionParametersKHR                 videoSessionParameters,
2869     const VkAllocationCallbacks*                pAllocator)
2870 {
2871 //Destroy object
2872 }
2873
2874 static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(
2875     VkCommandBuffer                             commandBuffer,
2876     const VkVideoBeginCodingInfoKHR*            pBeginInfo)
2877 {
2878 //Not a CREATE or DESTROY function
2879 }
2880
2881 static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(
2882     VkCommandBuffer                             commandBuffer,
2883     const VkVideoEndCodingInfoKHR*              pEndCodingInfo)
2884 {
2885 //Not a CREATE or DESTROY function
2886 }
2887
2888 static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(
2889     VkCommandBuffer                             commandBuffer,
2890     const VkVideoCodingControlInfoKHR*          pCodingControlInfo)
2891 {
2892 //Not a CREATE or DESTROY function
2893 }
2894 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2895
2896 #ifdef VK_ENABLE_BETA_EXTENSIONS
2897
2898 static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(
2899     VkCommandBuffer                             commandBuffer,
2900     const VkVideoDecodeInfoKHR*                 pFrameInfo)
2901 {
2902 //Not a CREATE or DESTROY function
2903 }
2904 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2905
2906
2907 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(
2908     VkCommandBuffer                             commandBuffer,
2909     const VkRenderingInfo*                      pRenderingInfo)
2910 {
2911 //Not a CREATE or DESTROY function
2912 }
2913
2914 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(
2915     VkCommandBuffer                             commandBuffer)
2916 {
2917 //Not a CREATE or DESTROY function
2918 }
2919
2920
2921
2922 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
2923     VkPhysicalDevice                            physicalDevice,
2924     VkPhysicalDeviceFeatures2*                  pFeatures)
2925 {
2926     GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
2927     uint32_t num_bools = 0; // Count number of VkBool32s in extension structs
2928     VkBool32* feat_bools = nullptr;
2929     const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext);
2930     if (desc_idx_features) {
2931         const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing);
2932         num_bools = bool_size/sizeof(VkBool32);
2933         feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing;
2934         SetBoolArrayTrue(feat_bools, num_bools);
2935     }
2936     const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext);
2937     if (blendop_features) {
2938         const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations);
2939         num_bools = bool_size/sizeof(VkBool32);
2940         feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations;
2941         SetBoolArrayTrue(feat_bools, num_bools);
2942     }
2943 }
2944
2945 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
2946     VkPhysicalDevice                            physicalDevice,
2947     VkPhysicalDeviceProperties2*                pProperties)
2948 {
2949     GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
2950     const auto *desc_idx_props = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingPropertiesEXT>(pProperties->pNext);
2951     if (desc_idx_props) {
2952         VkPhysicalDeviceDescriptorIndexingPropertiesEXT* write_props = (VkPhysicalDeviceDescriptorIndexingPropertiesEXT*)desc_idx_props;
2953         write_props->maxUpdateAfterBindDescriptorsInAllPools = 500000;
2954         write_props->shaderUniformBufferArrayNonUniformIndexingNative = false;
2955         write_props->shaderSampledImageArrayNonUniformIndexingNative = false;
2956         write_props->shaderStorageBufferArrayNonUniformIndexingNative = false;
2957         write_props->shaderStorageImageArrayNonUniformIndexingNative = false;
2958         write_props->shaderInputAttachmentArrayNonUniformIndexingNative = false;
2959         write_props->robustBufferAccessUpdateAfterBind = true;
2960         write_props->quadDivergentImplicitLod = true;
2961         write_props->maxPerStageDescriptorUpdateAfterBindSamplers = 500000;
2962         write_props->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 500000;
2963         write_props->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 500000;
2964         write_props->maxPerStageDescriptorUpdateAfterBindSampledImages = 500000;
2965         write_props->maxPerStageDescriptorUpdateAfterBindStorageImages = 500000;
2966         write_props->maxPerStageDescriptorUpdateAfterBindInputAttachments = 500000;
2967         write_props->maxPerStageUpdateAfterBindResources = 500000;
2968         write_props->maxDescriptorSetUpdateAfterBindSamplers = 500000;
2969         write_props->maxDescriptorSetUpdateAfterBindUniformBuffers = 96;
2970         write_props->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8;
2971         write_props->maxDescriptorSetUpdateAfterBindStorageBuffers = 500000;
2972         write_props->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 4;
2973         write_props->maxDescriptorSetUpdateAfterBindSampledImages = 500000;
2974         write_props->maxDescriptorSetUpdateAfterBindStorageImages = 500000;
2975         write_props->maxDescriptorSetUpdateAfterBindInputAttachments = 500000;
2976     }
2977
2978     const auto *push_descriptor_props = lvl_find_in_chain<VkPhysicalDevicePushDescriptorPropertiesKHR>(pProperties->pNext);
2979     if (push_descriptor_props) {
2980         VkPhysicalDevicePushDescriptorPropertiesKHR* write_props = (VkPhysicalDevicePushDescriptorPropertiesKHR*)push_descriptor_props;
2981         write_props->maxPushDescriptors = 256;
2982     }
2983
2984     const auto *depth_stencil_resolve_props = lvl_find_in_chain<VkPhysicalDeviceDepthStencilResolvePropertiesKHR>(pProperties->pNext);
2985     if (depth_stencil_resolve_props) {
2986         VkPhysicalDeviceDepthStencilResolvePropertiesKHR* write_props = (VkPhysicalDeviceDepthStencilResolvePropertiesKHR*)depth_stencil_resolve_props;
2987         write_props->supportedDepthResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
2988         write_props->supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
2989     }
2990
2991     const auto *fragment_density_map2_props = lvl_find_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext);
2992     if (fragment_density_map2_props) {
2993         VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* write_props = (VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*)fragment_density_map2_props;
2994         write_props->subsampledLoads = VK_FALSE;
2995         write_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE;
2996         write_props->maxSubsampledArrayLayers = 2;
2997         write_props->maxDescriptorSetSubsampledSamplers = 1;
2998     }
2999 }
3000
3001 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
3002     VkPhysicalDevice                            physicalDevice,
3003     VkFormat                                    format,
3004     VkFormatProperties2*                        pFormatProperties)
3005 {
3006     GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
3007     VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext);
3008     if (props_3) {
3009         props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures;
3010         props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures;
3011         props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures;
3012     }
3013 }
3014
3015 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
3016     VkPhysicalDevice                            physicalDevice,
3017     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
3018     VkImageFormatProperties2*                   pImageFormatProperties)
3019 {
3020     GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
3021     return VK_SUCCESS;
3022 }
3023
3024 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
3025     VkPhysicalDevice                            physicalDevice,
3026     uint32_t*                                   pQueueFamilyPropertyCount,
3027     VkQueueFamilyProperties2*                   pQueueFamilyProperties)
3028 {
3029     if (pQueueFamilyPropertyCount && pQueueFamilyProperties) {
3030         GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, &pQueueFamilyProperties->queueFamilyProperties);
3031     } else {
3032         GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, nullptr);
3033     }
3034 }
3035
3036 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
3037     VkPhysicalDevice                            physicalDevice,
3038     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties)
3039 {
3040     GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties);
3041 }
3042
3043 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
3044     VkPhysicalDevice                            physicalDevice,
3045     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
3046     uint32_t*                                   pPropertyCount,
3047     VkSparseImageFormatProperties2*             pProperties)
3048 {
3049 //Not a CREATE or DESTROY function
3050 }
3051
3052
3053 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
3054     VkDevice                                    device,
3055     uint32_t                                    heapIndex,
3056     uint32_t                                    localDeviceIndex,
3057     uint32_t                                    remoteDeviceIndex,
3058     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures)
3059 {
3060 //Not a CREATE or DESTROY function
3061 }
3062
3063 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
3064     VkCommandBuffer                             commandBuffer,
3065     uint32_t                                    deviceMask)
3066 {
3067 //Not a CREATE or DESTROY function
3068 }
3069
3070 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
3071     VkCommandBuffer                             commandBuffer,
3072     uint32_t                                    baseGroupX,
3073     uint32_t                                    baseGroupY,
3074     uint32_t                                    baseGroupZ,
3075     uint32_t                                    groupCountX,
3076     uint32_t                                    groupCountY,
3077     uint32_t                                    groupCountZ)
3078 {
3079 //Not a CREATE or DESTROY function
3080 }
3081
3082
3083
3084 static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
3085     VkDevice                                    device,
3086     VkCommandPool                               commandPool,
3087     VkCommandPoolTrimFlags                      flags)
3088 {
3089 //Not a CREATE or DESTROY function
3090 }
3091
3092
3093 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
3094     VkInstance                                  instance,
3095     uint32_t*                                   pPhysicalDeviceGroupCount,
3096     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties)
3097 {
3098 //Not a CREATE or DESTROY function
3099     return VK_SUCCESS;
3100 }
3101
3102
3103 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
3104     VkPhysicalDevice                            physicalDevice,
3105     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
3106     VkExternalBufferProperties*                 pExternalBufferProperties)
3107 {
3108     GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
3109 }
3110
3111
3112 #ifdef VK_USE_PLATFORM_WIN32_KHR
3113
3114 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
3115     VkDevice                                    device,
3116     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
3117     HANDLE*                                     pHandle)
3118 {
3119 //Not a CREATE or DESTROY function
3120     return VK_SUCCESS;
3121 }
3122
3123 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
3124     VkDevice                                    device,
3125     VkExternalMemoryHandleTypeFlagBits          handleType,
3126     HANDLE                                      handle,
3127     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties)
3128 {
3129 //Not a CREATE or DESTROY function
3130     return VK_SUCCESS;
3131 }
3132 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3133
3134
3135 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
3136     VkDevice                                    device,
3137     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
3138     int*                                        pFd)
3139 {
3140 //Not a CREATE or DESTROY function
3141     return VK_SUCCESS;
3142 }
3143
3144 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
3145     VkDevice                                    device,
3146     VkExternalMemoryHandleTypeFlagBits          handleType,
3147     int                                         fd,
3148     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties)
3149 {
3150 //Not a CREATE or DESTROY function
3151     return VK_SUCCESS;
3152 }
3153
3154 #ifdef VK_USE_PLATFORM_WIN32_KHR
3155 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3156
3157
3158 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
3159     VkPhysicalDevice                            physicalDevice,
3160     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
3161     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties)
3162 {
3163     GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
3164 }
3165
3166
3167 #ifdef VK_USE_PLATFORM_WIN32_KHR
3168
3169 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
3170     VkDevice                                    device,
3171     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo)
3172 {
3173 //Not a CREATE or DESTROY function
3174     return VK_SUCCESS;
3175 }
3176
3177 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
3178     VkDevice                                    device,
3179     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
3180     HANDLE*                                     pHandle)
3181 {
3182 //Not a CREATE or DESTROY function
3183     return VK_SUCCESS;
3184 }
3185 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3186
3187
3188 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
3189     VkDevice                                    device,
3190     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo)
3191 {
3192 //Not a CREATE or DESTROY function
3193     return VK_SUCCESS;
3194 }
3195
3196 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
3197     VkDevice                                    device,
3198     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
3199     int*                                        pFd)
3200 {
3201 //Not a CREATE or DESTROY function
3202     return VK_SUCCESS;
3203 }
3204
3205
3206 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
3207     VkCommandBuffer                             commandBuffer,
3208     VkPipelineBindPoint                         pipelineBindPoint,
3209     VkPipelineLayout                            layout,
3210     uint32_t                                    set,
3211     uint32_t                                    descriptorWriteCount,
3212     const VkWriteDescriptorSet*                 pDescriptorWrites)
3213 {
3214 //Not a CREATE or DESTROY function
3215 }
3216
3217 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
3218     VkCommandBuffer                             commandBuffer,
3219     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
3220     VkPipelineLayout                            layout,
3221     uint32_t                                    set,
3222     const void*                                 pData)
3223 {
3224 //Not a CREATE or DESTROY function
3225 }
3226
3227
3228
3229
3230
3231 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
3232     VkDevice                                    device,
3233     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
3234     const VkAllocationCallbacks*                pAllocator,
3235     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate)
3236 {
3237     unique_lock_t lock(global_lock);
3238     *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
3239     return VK_SUCCESS;
3240 }
3241
3242 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
3243     VkDevice                                    device,
3244     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
3245     const VkAllocationCallbacks*                pAllocator)
3246 {
3247 //Destroy object
3248 }
3249
3250 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
3251     VkDevice                                    device,
3252     VkDescriptorSet                             descriptorSet,
3253     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
3254     const void*                                 pData)
3255 {
3256 //Not a CREATE or DESTROY function
3257 }
3258
3259
3260
3261 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
3262     VkDevice                                    device,
3263     const VkRenderPassCreateInfo2*              pCreateInfo,
3264     const VkAllocationCallbacks*                pAllocator,
3265     VkRenderPass*                               pRenderPass)
3266 {
3267     unique_lock_t lock(global_lock);
3268     *pRenderPass = (VkRenderPass)global_unique_handle++;
3269     return VK_SUCCESS;
3270 }
3271
3272 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
3273     VkCommandBuffer                             commandBuffer,
3274     const VkRenderPassBeginInfo*                pRenderPassBegin,
3275     const VkSubpassBeginInfo*                   pSubpassBeginInfo)
3276 {
3277 //Not a CREATE or DESTROY function
3278 }
3279
3280 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
3281     VkCommandBuffer                             commandBuffer,
3282     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
3283     const VkSubpassEndInfo*                     pSubpassEndInfo)
3284 {
3285 //Not a CREATE or DESTROY function
3286 }
3287
3288 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
3289     VkCommandBuffer                             commandBuffer,
3290     const VkSubpassEndInfo*                     pSubpassEndInfo)
3291 {
3292 //Not a CREATE or DESTROY function
3293 }
3294
3295
3296 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
3297     VkDevice                                    device,
3298     VkSwapchainKHR                              swapchain)
3299 {
3300 //Not a CREATE or DESTROY function
3301     return VK_SUCCESS;
3302 }
3303
3304
3305 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
3306     VkPhysicalDevice                            physicalDevice,
3307     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
3308     VkExternalFenceProperties*                  pExternalFenceProperties)
3309 {
3310     GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
3311 }
3312
3313
3314 #ifdef VK_USE_PLATFORM_WIN32_KHR
3315
3316 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
3317     VkDevice                                    device,
3318     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo)
3319 {
3320 //Not a CREATE or DESTROY function
3321     return VK_SUCCESS;
3322 }
3323
3324 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
3325     VkDevice                                    device,
3326     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
3327     HANDLE*                                     pHandle)
3328 {
3329 //Not a CREATE or DESTROY function
3330     return VK_SUCCESS;
3331 }
3332 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3333
3334
3335 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
3336     VkDevice                                    device,
3337     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo)
3338 {
3339 //Not a CREATE or DESTROY function
3340     return VK_SUCCESS;
3341 }
3342
3343 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
3344     VkDevice                                    device,
3345     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
3346     int*                                        pFd)
3347 {
3348 //Not a CREATE or DESTROY function
3349     return VK_SUCCESS;
3350 }
3351
3352
3353 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
3354     VkPhysicalDevice                            physicalDevice,
3355     uint32_t                                    queueFamilyIndex,
3356     uint32_t*                                   pCounterCount,
3357     VkPerformanceCounterKHR*                    pCounters,
3358     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions)
3359 {
3360 //Not a CREATE or DESTROY function
3361     return VK_SUCCESS;
3362 }
3363
3364 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
3365     VkPhysicalDevice                            physicalDevice,
3366     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
3367     uint32_t*                                   pNumPasses)
3368 {
3369 //Not a CREATE or DESTROY function
3370 }
3371
3372 static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
3373     VkDevice                                    device,
3374     const VkAcquireProfilingLockInfoKHR*        pInfo)
3375 {
3376 //Not a CREATE or DESTROY function
3377     return VK_SUCCESS;
3378 }
3379
3380 static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
3381     VkDevice                                    device)
3382 {
3383 //Not a CREATE or DESTROY function
3384 }
3385
3386
3387
3388 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
3389     VkPhysicalDevice                            physicalDevice,
3390     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
3391     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities)
3392 {
3393     GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities);
3394     return VK_SUCCESS;
3395 }
3396
3397 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
3398     VkPhysicalDevice                            physicalDevice,
3399     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
3400     uint32_t*                                   pSurfaceFormatCount,
3401     VkSurfaceFormat2KHR*                        pSurfaceFormats)
3402 {
3403     // Currently always say that RGBA8 & BGRA8 are supported
3404     if (!pSurfaceFormats) {
3405         *pSurfaceFormatCount = 2;
3406     } else {
3407         // Intentionally falling through and just filling however many types are requested
3408         switch(*pSurfaceFormatCount) {
3409         case 2:
3410             pSurfaceFormats[1].pNext = nullptr;
3411             pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
3412             pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
3413             // fall through
3414         default:
3415             pSurfaceFormats[1].pNext = nullptr;
3416             pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM;
3417             pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
3418             break;
3419         }
3420     }
3421     return VK_SUCCESS;
3422 }
3423
3424
3425
3426 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
3427     VkPhysicalDevice                            physicalDevice,
3428     uint32_t*                                   pPropertyCount,
3429     VkDisplayProperties2KHR*                    pProperties)
3430 {
3431 //Not a CREATE or DESTROY function
3432     return VK_SUCCESS;
3433 }
3434
3435 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
3436     VkPhysicalDevice                            physicalDevice,
3437     uint32_t*                                   pPropertyCount,
3438     VkDisplayPlaneProperties2KHR*               pProperties)
3439 {
3440 //Not a CREATE or DESTROY function
3441     return VK_SUCCESS;
3442 }
3443
3444 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
3445     VkPhysicalDevice                            physicalDevice,
3446     VkDisplayKHR                                display,
3447     uint32_t*                                   pPropertyCount,
3448     VkDisplayModeProperties2KHR*                pProperties)
3449 {
3450 //Not a CREATE or DESTROY function
3451     return VK_SUCCESS;
3452 }
3453
3454 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
3455     VkPhysicalDevice                            physicalDevice,
3456     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
3457     VkDisplayPlaneCapabilities2KHR*             pCapabilities)
3458 {
3459 //Not a CREATE or DESTROY function
3460     return VK_SUCCESS;
3461 }
3462
3463
3464
3465
3466
3467 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
3468     VkDevice                                    device,
3469     const VkImageMemoryRequirementsInfo2*       pInfo,
3470     VkMemoryRequirements2*                      pMemoryRequirements)
3471 {
3472     GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
3473 }
3474
3475 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
3476     VkDevice                                    device,
3477     const VkBufferMemoryRequirementsInfo2*      pInfo,
3478     VkMemoryRequirements2*                      pMemoryRequirements)
3479 {
3480     GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
3481 }
3482
3483 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
3484     VkDevice                                    device,
3485     const VkImageSparseMemoryRequirementsInfo2* pInfo,
3486     uint32_t*                                   pSparseMemoryRequirementCount,
3487     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
3488 {
3489 //Not a CREATE or DESTROY function
3490 }
3491
3492
3493
3494 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
3495     VkDevice                                    device,
3496     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
3497     const VkAllocationCallbacks*                pAllocator,
3498     VkSamplerYcbcrConversion*                   pYcbcrConversion)
3499 {
3500     unique_lock_t lock(global_lock);
3501     *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
3502     return VK_SUCCESS;
3503 }
3504
3505 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
3506     VkDevice                                    device,
3507     VkSamplerYcbcrConversion                    ycbcrConversion,
3508     const VkAllocationCallbacks*                pAllocator)
3509 {
3510 //Destroy object
3511 }
3512
3513
3514 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
3515     VkDevice                                    device,
3516     uint32_t                                    bindInfoCount,
3517     const VkBindBufferMemoryInfo*               pBindInfos)
3518 {
3519 //Not a CREATE or DESTROY function
3520     return VK_SUCCESS;
3521 }
3522
3523 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
3524     VkDevice                                    device,
3525     uint32_t                                    bindInfoCount,
3526     const VkBindImageMemoryInfo*                pBindInfos)
3527 {
3528 //Not a CREATE or DESTROY function
3529     return VK_SUCCESS;
3530 }
3531
3532 #ifdef VK_ENABLE_BETA_EXTENSIONS
3533 #endif /* VK_ENABLE_BETA_EXTENSIONS */
3534
3535
3536 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
3537     VkDevice                                    device,
3538     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3539     VkDescriptorSetLayoutSupport*               pSupport)
3540 {
3541 //Not a CREATE or DESTROY function
3542 }
3543
3544
3545 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
3546     VkCommandBuffer                             commandBuffer,
3547     VkBuffer                                    buffer,
3548     VkDeviceSize                                offset,
3549     VkBuffer                                    countBuffer,
3550     VkDeviceSize                                countBufferOffset,
3551     uint32_t                                    maxDrawCount,
3552     uint32_t                                    stride)
3553 {
3554 //Not a CREATE or DESTROY function
3555 }
3556
3557 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
3558     VkCommandBuffer                             commandBuffer,
3559     VkBuffer                                    buffer,
3560     VkDeviceSize                                offset,
3561     VkBuffer                                    countBuffer,
3562     VkDeviceSize                                countBufferOffset,
3563     uint32_t                                    maxDrawCount,
3564     uint32_t                                    stride)
3565 {
3566 //Not a CREATE or DESTROY function
3567 }
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
3580     VkDevice                                    device,
3581     VkSemaphore                                 semaphore,
3582     uint64_t*                                   pValue)
3583 {
3584 //Not a CREATE or DESTROY function
3585     return VK_SUCCESS;
3586 }
3587
3588 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
3589     VkDevice                                    device,
3590     const VkSemaphoreWaitInfo*                  pWaitInfo,
3591     uint64_t                                    timeout)
3592 {
3593 //Not a CREATE or DESTROY function
3594     return VK_SUCCESS;
3595 }
3596
3597 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
3598     VkDevice                                    device,
3599     const VkSemaphoreSignalInfo*                pSignalInfo)
3600 {
3601 //Not a CREATE or DESTROY function
3602     return VK_SUCCESS;
3603 }
3604
3605
3606
3607
3608 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(
3609     VkPhysicalDevice                            physicalDevice,
3610     uint32_t*                                   pFragmentShadingRateCount,
3611     VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates)
3612 {
3613 //Not a CREATE or DESTROY function
3614     return VK_SUCCESS;
3615 }
3616
3617 static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(
3618     VkCommandBuffer                             commandBuffer,
3619     const VkExtent2D*                           pFragmentSize,
3620     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2])
3621 {
3622 //Not a CREATE or DESTROY function
3623 }
3624
3625
3626
3627
3628
3629 static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(
3630     VkDevice                                    device,
3631     VkSwapchainKHR                              swapchain,
3632     uint64_t                                    presentId,
3633     uint64_t                                    timeout)
3634 {
3635 //Not a CREATE or DESTROY function
3636     return VK_SUCCESS;
3637 }
3638
3639
3640
3641 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
3642     VkDevice                                    device,
3643     const VkBufferDeviceAddressInfo*            pInfo)
3644 {
3645 //Not a CREATE or DESTROY function
3646     return VK_SUCCESS;
3647 }
3648
3649 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
3650     VkDevice                                    device,
3651     const VkBufferDeviceAddressInfo*            pInfo)
3652 {
3653 //Not a CREATE or DESTROY function
3654     return VK_SUCCESS;
3655 }
3656
3657 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
3658     VkDevice                                    device,
3659     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
3660 {
3661 //Not a CREATE or DESTROY function
3662     return VK_SUCCESS;
3663 }
3664
3665
3666 static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
3667     VkDevice                                    device,
3668     const VkAllocationCallbacks*                pAllocator,
3669     VkDeferredOperationKHR*                     pDeferredOperation)
3670 {
3671     unique_lock_t lock(global_lock);
3672     *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++;
3673     return VK_SUCCESS;
3674 }
3675
3676 static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
3677     VkDevice                                    device,
3678     VkDeferredOperationKHR                      operation,
3679     const VkAllocationCallbacks*                pAllocator)
3680 {
3681 //Destroy object
3682 }
3683
3684 static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
3685     VkDevice                                    device,
3686     VkDeferredOperationKHR                      operation)
3687 {
3688 //Not a CREATE or DESTROY function
3689     return VK_SUCCESS;
3690 }
3691
3692 static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
3693     VkDevice                                    device,
3694     VkDeferredOperationKHR                      operation)
3695 {
3696 //Not a CREATE or DESTROY function
3697     return VK_SUCCESS;
3698 }
3699
3700 static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
3701     VkDevice                                    device,
3702     VkDeferredOperationKHR                      operation)
3703 {
3704 //Not a CREATE or DESTROY function
3705     return VK_SUCCESS;
3706 }
3707
3708
3709 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
3710     VkDevice                                    device,
3711     const VkPipelineInfoKHR*                    pPipelineInfo,
3712     uint32_t*                                   pExecutableCount,
3713     VkPipelineExecutablePropertiesKHR*          pProperties)
3714 {
3715 //Not a CREATE or DESTROY function
3716     return VK_SUCCESS;
3717 }
3718
3719 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
3720     VkDevice                                    device,
3721     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
3722     uint32_t*                                   pStatisticCount,
3723     VkPipelineExecutableStatisticKHR*           pStatistics)
3724 {
3725 //Not a CREATE or DESTROY function
3726     return VK_SUCCESS;
3727 }
3728
3729 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
3730     VkDevice                                    device,
3731     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
3732     uint32_t*                                   pInternalRepresentationCount,
3733     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
3734 {
3735 //Not a CREATE or DESTROY function
3736     return VK_SUCCESS;
3737 }
3738
3739
3740
3741
3742
3743 #ifdef VK_ENABLE_BETA_EXTENSIONS
3744
3745 static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(
3746     VkCommandBuffer                             commandBuffer,
3747     const VkVideoEncodeInfoKHR*                 pEncodeInfo)
3748 {
3749 //Not a CREATE or DESTROY function
3750 }
3751 #endif /* VK_ENABLE_BETA_EXTENSIONS */
3752
3753
3754 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(
3755     VkCommandBuffer                             commandBuffer,
3756     VkEvent                                     event,
3757     const VkDependencyInfo*                     pDependencyInfo)
3758 {
3759 //Not a CREATE or DESTROY function
3760 }
3761
3762 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(
3763     VkCommandBuffer                             commandBuffer,
3764     VkEvent                                     event,
3765     VkPipelineStageFlags2                       stageMask)
3766 {
3767 //Not a CREATE or DESTROY function
3768 }
3769
3770 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(
3771     VkCommandBuffer                             commandBuffer,
3772     uint32_t                                    eventCount,
3773     const VkEvent*                              pEvents,
3774     const VkDependencyInfo*                     pDependencyInfos)
3775 {
3776 //Not a CREATE or DESTROY function
3777 }
3778
3779 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(
3780     VkCommandBuffer                             commandBuffer,
3781     const VkDependencyInfo*                     pDependencyInfo)
3782 {
3783 //Not a CREATE or DESTROY function
3784 }
3785
3786 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(
3787     VkCommandBuffer                             commandBuffer,
3788     VkPipelineStageFlags2                       stage,
3789     VkQueryPool                                 queryPool,
3790     uint32_t                                    query)
3791 {
3792 //Not a CREATE or DESTROY function
3793 }
3794
3795 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(
3796     VkQueue                                     queue,
3797     uint32_t                                    submitCount,
3798     const VkSubmitInfo2*                        pSubmits,
3799     VkFence                                     fence)
3800 {
3801 //Not a CREATE or DESTROY function
3802     return VK_SUCCESS;
3803 }
3804
3805 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(
3806     VkCommandBuffer                             commandBuffer,
3807     VkPipelineStageFlags2                       stage,
3808     VkBuffer                                    dstBuffer,
3809     VkDeviceSize                                dstOffset,
3810     uint32_t                                    marker)
3811 {
3812 //Not a CREATE or DESTROY function
3813 }
3814
3815 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(
3816     VkQueue                                     queue,
3817     uint32_t*                                   pCheckpointDataCount,
3818     VkCheckpointData2NV*                        pCheckpointData)
3819 {
3820 //Not a CREATE or DESTROY function
3821 }
3822
3823
3824
3825
3826
3827 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(
3828     VkCommandBuffer                             commandBuffer,
3829     const VkCopyBufferInfo2*                    pCopyBufferInfo)
3830 {
3831 //Not a CREATE or DESTROY function
3832 }
3833
3834 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(
3835     VkCommandBuffer                             commandBuffer,
3836     const VkCopyImageInfo2*                     pCopyImageInfo)
3837 {
3838 //Not a CREATE or DESTROY function
3839 }
3840
3841 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(
3842     VkCommandBuffer                             commandBuffer,
3843     const VkCopyBufferToImageInfo2*             pCopyBufferToImageInfo)
3844 {
3845 //Not a CREATE or DESTROY function
3846 }
3847
3848 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(
3849     VkCommandBuffer                             commandBuffer,
3850     const VkCopyImageToBufferInfo2*             pCopyImageToBufferInfo)
3851 {
3852 //Not a CREATE or DESTROY function
3853 }
3854
3855 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(
3856     VkCommandBuffer                             commandBuffer,
3857     const VkBlitImageInfo2*                     pBlitImageInfo)
3858 {
3859 //Not a CREATE or DESTROY function
3860 }
3861
3862 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(
3863     VkCommandBuffer                             commandBuffer,
3864     const VkResolveImageInfo2*                  pResolveImageInfo)
3865 {
3866 //Not a CREATE or DESTROY function
3867 }
3868
3869
3870
3871 static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(
3872     VkDevice                                    device,
3873     const VkDeviceBufferMemoryRequirements*     pInfo,
3874     VkMemoryRequirements2*                      pMemoryRequirements)
3875 {
3876 //Not a CREATE or DESTROY function
3877 }
3878
3879 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(
3880     VkDevice                                    device,
3881     const VkDeviceImageMemoryRequirements*      pInfo,
3882     VkMemoryRequirements2*                      pMemoryRequirements)
3883 {
3884 //Not a CREATE or DESTROY function
3885 }
3886
3887 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
3888     VkDevice                                    device,
3889     const VkDeviceImageMemoryRequirements*      pInfo,
3890     uint32_t*                                   pSparseMemoryRequirementCount,
3891     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
3892 {
3893 //Not a CREATE or DESTROY function
3894 }
3895
3896
3897 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
3898     VkInstance                                  instance,
3899     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
3900     const VkAllocationCallbacks*                pAllocator,
3901     VkDebugReportCallbackEXT*                   pCallback)
3902 {
3903     unique_lock_t lock(global_lock);
3904     *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++;
3905     return VK_SUCCESS;
3906 }
3907
3908 static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
3909     VkInstance                                  instance,
3910     VkDebugReportCallbackEXT                    callback,
3911     const VkAllocationCallbacks*                pAllocator)
3912 {
3913 //Destroy object
3914 }
3915
3916 static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
3917     VkInstance                                  instance,
3918     VkDebugReportFlagsEXT                       flags,
3919     VkDebugReportObjectTypeEXT                  objectType,
3920     uint64_t                                    object,
3921     size_t                                      location,
3922     int32_t                                     messageCode,
3923     const char*                                 pLayerPrefix,
3924     const char*                                 pMessage)
3925 {
3926 //Not a CREATE or DESTROY function
3927 }
3928
3929
3930
3931
3932
3933
3934
3935
3936 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
3937     VkDevice                                    device,
3938     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo)
3939 {
3940 //Not a CREATE or DESTROY function
3941     return VK_SUCCESS;
3942 }
3943
3944 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
3945     VkDevice                                    device,
3946     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo)
3947 {
3948 //Not a CREATE or DESTROY function
3949     return VK_SUCCESS;
3950 }
3951
3952 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
3953     VkCommandBuffer                             commandBuffer,
3954     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo)
3955 {
3956 //Not a CREATE or DESTROY function
3957 }
3958
3959 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
3960     VkCommandBuffer                             commandBuffer)
3961 {
3962 //Not a CREATE or DESTROY function
3963 }
3964
3965 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
3966     VkCommandBuffer                             commandBuffer,
3967     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo)
3968 {
3969 //Not a CREATE or DESTROY function
3970 }
3971
3972
3973
3974
3975 static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
3976     VkCommandBuffer                             commandBuffer,
3977     uint32_t                                    firstBinding,
3978     uint32_t                                    bindingCount,
3979     const VkBuffer*                             pBuffers,
3980     const VkDeviceSize*                         pOffsets,
3981     const VkDeviceSize*                         pSizes)
3982 {
3983 //Not a CREATE or DESTROY function
3984 }
3985
3986 static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
3987     VkCommandBuffer                             commandBuffer,
3988     uint32_t                                    firstCounterBuffer,
3989     uint32_t                                    counterBufferCount,
3990     const VkBuffer*                             pCounterBuffers,
3991     const VkDeviceSize*                         pCounterBufferOffsets)
3992 {
3993 //Not a CREATE or DESTROY function
3994 }
3995
3996 static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
3997     VkCommandBuffer                             commandBuffer,
3998     uint32_t                                    firstCounterBuffer,
3999     uint32_t                                    counterBufferCount,
4000     const VkBuffer*                             pCounterBuffers,
4001     const VkDeviceSize*                         pCounterBufferOffsets)
4002 {
4003 //Not a CREATE or DESTROY function
4004 }
4005
4006 static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
4007     VkCommandBuffer                             commandBuffer,
4008     VkQueryPool                                 queryPool,
4009     uint32_t                                    query,
4010     VkQueryControlFlags                         flags,
4011     uint32_t                                    index)
4012 {
4013 //Not a CREATE or DESTROY function
4014 }
4015
4016 static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
4017     VkCommandBuffer                             commandBuffer,
4018     VkQueryPool                                 queryPool,
4019     uint32_t                                    query,
4020     uint32_t                                    index)
4021 {
4022 //Not a CREATE or DESTROY function
4023 }
4024
4025 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
4026     VkCommandBuffer                             commandBuffer,
4027     uint32_t                                    instanceCount,
4028     uint32_t                                    firstInstance,
4029     VkBuffer                                    counterBuffer,
4030     VkDeviceSize                                counterBufferOffset,
4031     uint32_t                                    counterOffset,
4032     uint32_t                                    vertexStride)
4033 {
4034 //Not a CREATE or DESTROY function
4035 }
4036
4037
4038 static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(
4039     VkDevice                                    device,
4040     const VkCuModuleCreateInfoNVX*              pCreateInfo,
4041     const VkAllocationCallbacks*                pAllocator,
4042     VkCuModuleNVX*                              pModule)
4043 {
4044     unique_lock_t lock(global_lock);
4045     *pModule = (VkCuModuleNVX)global_unique_handle++;
4046     return VK_SUCCESS;
4047 }
4048
4049 static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(
4050     VkDevice                                    device,
4051     const VkCuFunctionCreateInfoNVX*            pCreateInfo,
4052     const VkAllocationCallbacks*                pAllocator,
4053     VkCuFunctionNVX*                            pFunction)
4054 {
4055     unique_lock_t lock(global_lock);
4056     *pFunction = (VkCuFunctionNVX)global_unique_handle++;
4057     return VK_SUCCESS;
4058 }
4059
4060 static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(
4061     VkDevice                                    device,
4062     VkCuModuleNVX                               module,
4063     const VkAllocationCallbacks*                pAllocator)
4064 {
4065 //Destroy object
4066 }
4067
4068 static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(
4069     VkDevice                                    device,
4070     VkCuFunctionNVX                             function,
4071     const VkAllocationCallbacks*                pAllocator)
4072 {
4073 //Destroy object
4074 }
4075
4076 static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(
4077     VkCommandBuffer                             commandBuffer,
4078     const VkCuLaunchInfoNVX*                    pLaunchInfo)
4079 {
4080 //Not a CREATE or DESTROY function
4081 }
4082
4083
4084 static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
4085     VkDevice                                    device,
4086     const VkImageViewHandleInfoNVX*             pInfo)
4087 {
4088 //Not a CREATE or DESTROY function
4089     return VK_SUCCESS;
4090 }
4091
4092 static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(
4093     VkDevice                                    device,
4094     VkImageView                                 imageView,
4095     VkImageViewAddressPropertiesNVX*            pProperties)
4096 {
4097 //Not a CREATE or DESTROY function
4098     return VK_SUCCESS;
4099 }
4100
4101
4102 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
4103     VkCommandBuffer                             commandBuffer,
4104     VkBuffer                                    buffer,
4105     VkDeviceSize                                offset,
4106     VkBuffer                                    countBuffer,
4107     VkDeviceSize                                countBufferOffset,
4108     uint32_t                                    maxDrawCount,
4109     uint32_t                                    stride)
4110 {
4111 //Not a CREATE or DESTROY function
4112 }
4113
4114 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
4115     VkCommandBuffer                             commandBuffer,
4116     VkBuffer                                    buffer,
4117     VkDeviceSize                                offset,
4118     VkBuffer                                    countBuffer,
4119     VkDeviceSize                                countBufferOffset,
4120     uint32_t                                    maxDrawCount,
4121     uint32_t                                    stride)
4122 {
4123 //Not a CREATE or DESTROY function
4124 }
4125
4126
4127
4128
4129 #ifdef VK_ENABLE_BETA_EXTENSIONS
4130 #endif /* VK_ENABLE_BETA_EXTENSIONS */
4131
4132 #ifdef VK_ENABLE_BETA_EXTENSIONS
4133 #endif /* VK_ENABLE_BETA_EXTENSIONS */
4134
4135 #ifdef VK_ENABLE_BETA_EXTENSIONS
4136 #endif /* VK_ENABLE_BETA_EXTENSIONS */
4137
4138
4139
4140 static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
4141     VkDevice                                    device,
4142     VkPipeline                                  pipeline,
4143     VkShaderStageFlagBits                       shaderStage,
4144     VkShaderInfoTypeAMD                         infoType,
4145     size_t*                                     pInfoSize,
4146     void*                                       pInfo)
4147 {
4148 //Not a CREATE or DESTROY function
4149     return VK_SUCCESS;
4150 }
4151
4152
4153 #ifdef VK_USE_PLATFORM_GGP
4154
4155 static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
4156     VkInstance                                  instance,
4157     const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
4158     const VkAllocationCallbacks*                pAllocator,
4159     VkSurfaceKHR*                               pSurface)
4160 {
4161     unique_lock_t lock(global_lock);
4162     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4163     return VK_SUCCESS;
4164 }
4165 #endif /* VK_USE_PLATFORM_GGP */
4166
4167
4168
4169
4170 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
4171     VkPhysicalDevice                            physicalDevice,
4172     VkFormat                                    format,
4173     VkImageType                                 type,
4174     VkImageTiling                               tiling,
4175     VkImageUsageFlags                           usage,
4176     VkImageCreateFlags                          flags,
4177     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
4178     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties)
4179 {
4180 //Not a CREATE or DESTROY function
4181     return VK_SUCCESS;
4182 }
4183
4184
4185 #ifdef VK_USE_PLATFORM_WIN32_KHR
4186
4187 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
4188     VkDevice                                    device,
4189     VkDeviceMemory                              memory,
4190     VkExternalMemoryHandleTypeFlagsNV           handleType,
4191     HANDLE*                                     pHandle)
4192 {
4193 //Not a CREATE or DESTROY function
4194     return VK_SUCCESS;
4195 }
4196 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4197
4198 #ifdef VK_USE_PLATFORM_WIN32_KHR
4199 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4200
4201
4202 #ifdef VK_USE_PLATFORM_VI_NN
4203
4204 static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
4205     VkInstance                                  instance,
4206     const VkViSurfaceCreateInfoNN*              pCreateInfo,
4207     const VkAllocationCallbacks*                pAllocator,
4208     VkSurfaceKHR*                               pSurface)
4209 {
4210     unique_lock_t lock(global_lock);
4211     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4212     return VK_SUCCESS;
4213 }
4214 #endif /* VK_USE_PLATFORM_VI_NN */
4215
4216
4217
4218
4219
4220
4221 static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
4222     VkCommandBuffer                             commandBuffer,
4223     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin)
4224 {
4225 //Not a CREATE or DESTROY function
4226 }
4227
4228 static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
4229     VkCommandBuffer                             commandBuffer)
4230 {
4231 //Not a CREATE or DESTROY function
4232 }
4233
4234
4235 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
4236     VkCommandBuffer                             commandBuffer,
4237     uint32_t                                    firstViewport,
4238     uint32_t                                    viewportCount,
4239     const VkViewportWScalingNV*                 pViewportWScalings)
4240 {
4241 //Not a CREATE or DESTROY function
4242 }
4243
4244
4245 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
4246     VkPhysicalDevice                            physicalDevice,
4247     VkDisplayKHR                                display)
4248 {
4249 //Not a CREATE or DESTROY function
4250     return VK_SUCCESS;
4251 }
4252
4253 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
4254
4255 static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
4256     VkPhysicalDevice                            physicalDevice,
4257     Display*                                    dpy,
4258     VkDisplayKHR                                display)
4259 {
4260 //Not a CREATE or DESTROY function
4261     return VK_SUCCESS;
4262 }
4263
4264 static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
4265     VkPhysicalDevice                            physicalDevice,
4266     Display*                                    dpy,
4267     RROutput                                    rrOutput,
4268     VkDisplayKHR*                               pDisplay)
4269 {
4270 //Not a CREATE or DESTROY function
4271     return VK_SUCCESS;
4272 }
4273 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
4274
4275
4276 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
4277     VkPhysicalDevice                            physicalDevice,
4278     VkSurfaceKHR                                surface,
4279     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities)
4280 {
4281 //Not a CREATE or DESTROY function
4282     return VK_SUCCESS;
4283 }
4284
4285
4286 static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
4287     VkDevice                                    device,
4288     VkDisplayKHR                                display,
4289     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo)
4290 {
4291 //Not a CREATE or DESTROY function
4292     return VK_SUCCESS;
4293 }
4294
4295 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
4296     VkDevice                                    device,
4297     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
4298     const VkAllocationCallbacks*                pAllocator,
4299     VkFence*                                    pFence)
4300 {
4301 //Not a CREATE or DESTROY function
4302     return VK_SUCCESS;
4303 }
4304
4305 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
4306     VkDevice                                    device,
4307     VkDisplayKHR                                display,
4308     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
4309     const VkAllocationCallbacks*                pAllocator,
4310     VkFence*                                    pFence)
4311 {
4312 //Not a CREATE or DESTROY function
4313     return VK_SUCCESS;
4314 }
4315
4316 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
4317     VkDevice                                    device,
4318     VkSwapchainKHR                              swapchain,
4319     VkSurfaceCounterFlagBitsEXT                 counter,
4320     uint64_t*                                   pCounterValue)
4321 {
4322 //Not a CREATE or DESTROY function
4323     return VK_SUCCESS;
4324 }
4325
4326
4327 static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
4328     VkDevice                                    device,
4329     VkSwapchainKHR                              swapchain,
4330     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties)
4331 {
4332 //Not a CREATE or DESTROY function
4333     return VK_SUCCESS;
4334 }
4335
4336 static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
4337     VkDevice                                    device,
4338     VkSwapchainKHR                              swapchain,
4339     uint32_t*                                   pPresentationTimingCount,
4340     VkPastPresentationTimingGOOGLE*             pPresentationTimings)
4341 {
4342 //Not a CREATE or DESTROY function
4343     return VK_SUCCESS;
4344 }
4345
4346
4347
4348
4349
4350
4351
4352 static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
4353     VkCommandBuffer                             commandBuffer,
4354     uint32_t                                    firstDiscardRectangle,
4355     uint32_t                                    discardRectangleCount,
4356     const VkRect2D*                             pDiscardRectangles)
4357 {
4358 //Not a CREATE or DESTROY function
4359 }
4360
4361
4362
4363
4364
4365 static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
4366     VkDevice                                    device,
4367     uint32_t                                    swapchainCount,
4368     const VkSwapchainKHR*                       pSwapchains,
4369     const VkHdrMetadataEXT*                     pMetadata)
4370 {
4371 //Not a CREATE or DESTROY function
4372 }
4373
4374 #ifdef VK_USE_PLATFORM_IOS_MVK
4375
4376 static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
4377     VkInstance                                  instance,
4378     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
4379     const VkAllocationCallbacks*                pAllocator,
4380     VkSurfaceKHR*                               pSurface)
4381 {
4382     unique_lock_t lock(global_lock);
4383     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4384     return VK_SUCCESS;
4385 }
4386 #endif /* VK_USE_PLATFORM_IOS_MVK */
4387
4388 #ifdef VK_USE_PLATFORM_MACOS_MVK
4389
4390 static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
4391     VkInstance                                  instance,
4392     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
4393     const VkAllocationCallbacks*                pAllocator,
4394     VkSurfaceKHR*                               pSurface)
4395 {
4396     unique_lock_t lock(global_lock);
4397     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4398     return VK_SUCCESS;
4399 }
4400 #endif /* VK_USE_PLATFORM_MACOS_MVK */
4401
4402
4403
4404
4405 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
4406     VkDevice                                    device,
4407     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo)
4408 {
4409 //Not a CREATE or DESTROY function
4410     return VK_SUCCESS;
4411 }
4412
4413 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
4414     VkDevice                                    device,
4415     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo)
4416 {
4417 //Not a CREATE or DESTROY function
4418     return VK_SUCCESS;
4419 }
4420
4421 static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
4422     VkQueue                                     queue,
4423     const VkDebugUtilsLabelEXT*                 pLabelInfo)
4424 {
4425 //Not a CREATE or DESTROY function
4426 }
4427
4428 static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
4429     VkQueue                                     queue)
4430 {
4431 //Not a CREATE or DESTROY function
4432 }
4433
4434 static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
4435     VkQueue                                     queue,
4436     const VkDebugUtilsLabelEXT*                 pLabelInfo)
4437 {
4438 //Not a CREATE or DESTROY function
4439 }
4440
4441 static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
4442     VkCommandBuffer                             commandBuffer,
4443     const VkDebugUtilsLabelEXT*                 pLabelInfo)
4444 {
4445 //Not a CREATE or DESTROY function
4446 }
4447
4448 static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
4449     VkCommandBuffer                             commandBuffer)
4450 {
4451 //Not a CREATE or DESTROY function
4452 }
4453
4454 static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
4455     VkCommandBuffer                             commandBuffer,
4456     const VkDebugUtilsLabelEXT*                 pLabelInfo)
4457 {
4458 //Not a CREATE or DESTROY function
4459 }
4460
4461 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
4462     VkInstance                                  instance,
4463     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
4464     const VkAllocationCallbacks*                pAllocator,
4465     VkDebugUtilsMessengerEXT*                   pMessenger)
4466 {
4467     unique_lock_t lock(global_lock);
4468     *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++;
4469     return VK_SUCCESS;
4470 }
4471
4472 static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
4473     VkInstance                                  instance,
4474     VkDebugUtilsMessengerEXT                    messenger,
4475     const VkAllocationCallbacks*                pAllocator)
4476 {
4477 //Destroy object
4478 }
4479
4480 static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
4481     VkInstance                                  instance,
4482     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
4483     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
4484     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
4485 {
4486 //Not a CREATE or DESTROY function
4487 }
4488
4489 #ifdef VK_USE_PLATFORM_ANDROID_KHR
4490
4491 static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
4492     VkDevice                                    device,
4493     const struct AHardwareBuffer*               buffer,
4494     VkAndroidHardwareBufferPropertiesANDROID*   pProperties)
4495 {
4496 //Not a CREATE or DESTROY function
4497     return VK_SUCCESS;
4498 }
4499
4500 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
4501     VkDevice                                    device,
4502     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
4503     struct AHardwareBuffer**                    pBuffer)
4504 {
4505 //Not a CREATE or DESTROY function
4506     return VK_SUCCESS;
4507 }
4508 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
4509
4510
4511
4512
4513
4514
4515
4516
4517 static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
4518     VkCommandBuffer                             commandBuffer,
4519     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo)
4520 {
4521 //Not a CREATE or DESTROY function
4522 }
4523
4524 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
4525     VkPhysicalDevice                            physicalDevice,
4526     VkSampleCountFlagBits                       samples,
4527     VkMultisamplePropertiesEXT*                 pMultisampleProperties)
4528 {
4529 //Not a CREATE or DESTROY function
4530 }
4531
4532
4533
4534
4535
4536
4537
4538
4539 static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
4540     VkDevice                                    device,
4541     VkImage                                     image,
4542     VkImageDrmFormatModifierPropertiesEXT*      pProperties)
4543 {
4544 //Not a CREATE or DESTROY function
4545     return VK_SUCCESS;
4546 }
4547
4548
4549 static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
4550     VkDevice                                    device,
4551     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
4552     const VkAllocationCallbacks*                pAllocator,
4553     VkValidationCacheEXT*                       pValidationCache)
4554 {
4555     unique_lock_t lock(global_lock);
4556     *pValidationCache = (VkValidationCacheEXT)global_unique_handle++;
4557     return VK_SUCCESS;
4558 }
4559
4560 static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
4561     VkDevice                                    device,
4562     VkValidationCacheEXT                        validationCache,
4563     const VkAllocationCallbacks*                pAllocator)
4564 {
4565 //Destroy object
4566 }
4567
4568 static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
4569     VkDevice                                    device,
4570     VkValidationCacheEXT                        dstCache,
4571     uint32_t                                    srcCacheCount,
4572     const VkValidationCacheEXT*                 pSrcCaches)
4573 {
4574 //Not a CREATE or DESTROY function
4575     return VK_SUCCESS;
4576 }
4577
4578 static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
4579     VkDevice                                    device,
4580     VkValidationCacheEXT                        validationCache,
4581     size_t*                                     pDataSize,
4582     void*                                       pData)
4583 {
4584 //Not a CREATE or DESTROY function
4585     return VK_SUCCESS;
4586 }
4587
4588
4589
4590
4591 static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
4592     VkCommandBuffer                             commandBuffer,
4593     VkImageView                                 imageView,
4594     VkImageLayout                               imageLayout)
4595 {
4596 //Not a CREATE or DESTROY function
4597 }
4598
4599 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
4600     VkCommandBuffer                             commandBuffer,
4601     uint32_t                                    firstViewport,
4602     uint32_t                                    viewportCount,
4603     const VkShadingRatePaletteNV*               pShadingRatePalettes)
4604 {
4605 //Not a CREATE or DESTROY function
4606 }
4607
4608 static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
4609     VkCommandBuffer                             commandBuffer,
4610     VkCoarseSampleOrderTypeNV                   sampleOrderType,
4611     uint32_t                                    customSampleOrderCount,
4612     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders)
4613 {
4614 //Not a CREATE or DESTROY function
4615 }
4616
4617
4618 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
4619     VkDevice                                    device,
4620     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
4621     const VkAllocationCallbacks*                pAllocator,
4622     VkAccelerationStructureNV*                  pAccelerationStructure)
4623 {
4624     unique_lock_t lock(global_lock);
4625     *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++;
4626     return VK_SUCCESS;
4627 }
4628
4629 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
4630     VkDevice                                    device,
4631     VkAccelerationStructureNV                   accelerationStructure,
4632     const VkAllocationCallbacks*                pAllocator)
4633 {
4634 //Destroy object
4635 }
4636
4637 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
4638     VkDevice                                    device,
4639     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
4640     VkMemoryRequirements2KHR*                   pMemoryRequirements)
4641 {
4642 //Not a CREATE or DESTROY function
4643 }
4644
4645 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
4646     VkDevice                                    device,
4647     uint32_t                                    bindInfoCount,
4648     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
4649 {
4650 //Not a CREATE or DESTROY function
4651     return VK_SUCCESS;
4652 }
4653
4654 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
4655     VkCommandBuffer                             commandBuffer,
4656     const VkAccelerationStructureInfoNV*        pInfo,
4657     VkBuffer                                    instanceData,
4658     VkDeviceSize                                instanceOffset,
4659     VkBool32                                    update,
4660     VkAccelerationStructureNV                   dst,
4661     VkAccelerationStructureNV                   src,
4662     VkBuffer                                    scratch,
4663     VkDeviceSize                                scratchOffset)
4664 {
4665 //Not a CREATE or DESTROY function
4666 }
4667
4668 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
4669     VkCommandBuffer                             commandBuffer,
4670     VkAccelerationStructureNV                   dst,
4671     VkAccelerationStructureNV                   src,
4672     VkCopyAccelerationStructureModeKHR          mode)
4673 {
4674 //Not a CREATE or DESTROY function
4675 }
4676
4677 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
4678     VkCommandBuffer                             commandBuffer,
4679     VkBuffer                                    raygenShaderBindingTableBuffer,
4680     VkDeviceSize                                raygenShaderBindingOffset,
4681     VkBuffer                                    missShaderBindingTableBuffer,
4682     VkDeviceSize                                missShaderBindingOffset,
4683     VkDeviceSize                                missShaderBindingStride,
4684     VkBuffer                                    hitShaderBindingTableBuffer,
4685     VkDeviceSize                                hitShaderBindingOffset,
4686     VkDeviceSize                                hitShaderBindingStride,
4687     VkBuffer                                    callableShaderBindingTableBuffer,
4688     VkDeviceSize                                callableShaderBindingOffset,
4689     VkDeviceSize                                callableShaderBindingStride,
4690     uint32_t                                    width,
4691     uint32_t                                    height,
4692     uint32_t                                    depth)
4693 {
4694 //Not a CREATE or DESTROY function
4695 }
4696
4697 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
4698     VkDevice                                    device,
4699     VkPipelineCache                             pipelineCache,
4700     uint32_t                                    createInfoCount,
4701     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
4702     const VkAllocationCallbacks*                pAllocator,
4703     VkPipeline*                                 pPipelines)
4704 {
4705     unique_lock_t lock(global_lock);
4706     for (uint32_t i = 0; i < createInfoCount; ++i) {
4707         pPipelines[i] = (VkPipeline)global_unique_handle++;
4708     }
4709     return VK_SUCCESS;
4710 }
4711
4712 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
4713     VkDevice                                    device,
4714     VkPipeline                                  pipeline,
4715     uint32_t                                    firstGroup,
4716     uint32_t                                    groupCount,
4717     size_t                                      dataSize,
4718     void*                                       pData)
4719 {
4720 //Not a CREATE or DESTROY function
4721     return VK_SUCCESS;
4722 }
4723
4724 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
4725     VkDevice                                    device,
4726     VkPipeline                                  pipeline,
4727     uint32_t                                    firstGroup,
4728     uint32_t                                    groupCount,
4729     size_t                                      dataSize,
4730     void*                                       pData)
4731 {
4732 //Not a CREATE or DESTROY function
4733     return VK_SUCCESS;
4734 }
4735
4736 static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
4737     VkDevice                                    device,
4738     VkAccelerationStructureNV                   accelerationStructure,
4739     size_t                                      dataSize,
4740     void*                                       pData)
4741 {
4742 //Not a CREATE or DESTROY function
4743     return VK_SUCCESS;
4744 }
4745
4746 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
4747     VkCommandBuffer                             commandBuffer,
4748     uint32_t                                    accelerationStructureCount,
4749     const VkAccelerationStructureNV*            pAccelerationStructures,
4750     VkQueryType                                 queryType,
4751     VkQueryPool                                 queryPool,
4752     uint32_t                                    firstQuery)
4753 {
4754 //Not a CREATE or DESTROY function
4755 }
4756
4757 static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
4758     VkDevice                                    device,
4759     VkPipeline                                  pipeline,
4760     uint32_t                                    shader)
4761 {
4762 //Not a CREATE or DESTROY function
4763     return VK_SUCCESS;
4764 }
4765
4766
4767
4768
4769
4770
4771 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
4772     VkDevice                                    device,
4773     VkExternalMemoryHandleTypeFlagBits          handleType,
4774     const void*                                 pHostPointer,
4775     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties)
4776 {
4777 //Not a CREATE or DESTROY function
4778     return VK_SUCCESS;
4779 }
4780
4781
4782 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
4783     VkCommandBuffer                             commandBuffer,
4784     VkPipelineStageFlagBits                     pipelineStage,
4785     VkBuffer                                    dstBuffer,
4786     VkDeviceSize                                dstOffset,
4787     uint32_t                                    marker)
4788 {
4789 //Not a CREATE or DESTROY function
4790 }
4791
4792
4793
4794 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
4795     VkPhysicalDevice                            physicalDevice,
4796     uint32_t*                                   pTimeDomainCount,
4797     VkTimeDomainEXT*                            pTimeDomains)
4798 {
4799 //Not a CREATE or DESTROY function
4800     return VK_SUCCESS;
4801 }
4802
4803 static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
4804     VkDevice                                    device,
4805     uint32_t                                    timestampCount,
4806     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
4807     uint64_t*                                   pTimestamps,
4808     uint64_t*                                   pMaxDeviation)
4809 {
4810 //Not a CREATE or DESTROY function
4811     return VK_SUCCESS;
4812 }
4813
4814
4815 #ifdef VK_ENABLE_BETA_EXTENSIONS
4816 #endif /* VK_ENABLE_BETA_EXTENSIONS */
4817
4818
4819
4820 #ifdef VK_USE_PLATFORM_GGP
4821 #endif /* VK_USE_PLATFORM_GGP */
4822
4823
4824
4825
4826
4827 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
4828     VkCommandBuffer                             commandBuffer,
4829     uint32_t                                    taskCount,
4830     uint32_t                                    firstTask)
4831 {
4832 //Not a CREATE or DESTROY function
4833 }
4834
4835 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
4836     VkCommandBuffer                             commandBuffer,
4837     VkBuffer                                    buffer,
4838     VkDeviceSize                                offset,
4839     uint32_t                                    drawCount,
4840     uint32_t                                    stride)
4841 {
4842 //Not a CREATE or DESTROY function
4843 }
4844
4845 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
4846     VkCommandBuffer                             commandBuffer,
4847     VkBuffer                                    buffer,
4848     VkDeviceSize                                offset,
4849     VkBuffer                                    countBuffer,
4850     VkDeviceSize                                countBufferOffset,
4851     uint32_t                                    maxDrawCount,
4852     uint32_t                                    stride)
4853 {
4854 //Not a CREATE or DESTROY function
4855 }
4856
4857
4858
4859
4860 static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
4861     VkCommandBuffer                             commandBuffer,
4862     uint32_t                                    firstExclusiveScissor,
4863     uint32_t                                    exclusiveScissorCount,
4864     const VkRect2D*                             pExclusiveScissors)
4865 {
4866 //Not a CREATE or DESTROY function
4867 }
4868
4869
4870 static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
4871     VkCommandBuffer                             commandBuffer,
4872     const void*                                 pCheckpointMarker)
4873 {
4874 //Not a CREATE or DESTROY function
4875 }
4876
4877 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
4878     VkQueue                                     queue,
4879     uint32_t*                                   pCheckpointDataCount,
4880     VkCheckpointDataNV*                         pCheckpointData)
4881 {
4882 //Not a CREATE or DESTROY function
4883 }
4884
4885
4886
4887 static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
4888     VkDevice                                    device,
4889     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo)
4890 {
4891 //Not a CREATE or DESTROY function
4892     return VK_SUCCESS;
4893 }
4894
4895 static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
4896     VkDevice                                    device)
4897 {
4898 //Not a CREATE or DESTROY function
4899 }
4900
4901 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
4902     VkCommandBuffer                             commandBuffer,
4903     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo)
4904 {
4905 //Not a CREATE or DESTROY function
4906     return VK_SUCCESS;
4907 }
4908
4909 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
4910     VkCommandBuffer                             commandBuffer,
4911     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo)
4912 {
4913 //Not a CREATE or DESTROY function
4914     return VK_SUCCESS;
4915 }
4916
4917 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
4918     VkCommandBuffer                             commandBuffer,
4919     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo)
4920 {
4921 //Not a CREATE or DESTROY function
4922     return VK_SUCCESS;
4923 }
4924
4925 static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
4926     VkDevice                                    device,
4927     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
4928     VkPerformanceConfigurationINTEL*            pConfiguration)
4929 {
4930 //Not a CREATE or DESTROY function
4931     return VK_SUCCESS;
4932 }
4933
4934 static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
4935     VkDevice                                    device,
4936     VkPerformanceConfigurationINTEL             configuration)
4937 {
4938 //Not a CREATE or DESTROY function
4939     return VK_SUCCESS;
4940 }
4941
4942 static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
4943     VkQueue                                     queue,
4944     VkPerformanceConfigurationINTEL             configuration)
4945 {
4946 //Not a CREATE or DESTROY function
4947     return VK_SUCCESS;
4948 }
4949
4950 static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
4951     VkDevice                                    device,
4952     VkPerformanceParameterTypeINTEL             parameter,
4953     VkPerformanceValueINTEL*                    pValue)
4954 {
4955 //Not a CREATE or DESTROY function
4956     return VK_SUCCESS;
4957 }
4958
4959
4960
4961 static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
4962     VkDevice                                    device,
4963     VkSwapchainKHR                              swapChain,
4964     VkBool32                                    localDimmingEnable)
4965 {
4966 //Not a CREATE or DESTROY function
4967 }
4968
4969 #ifdef VK_USE_PLATFORM_FUCHSIA
4970
4971 static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
4972     VkInstance                                  instance,
4973     const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
4974     const VkAllocationCallbacks*                pAllocator,
4975     VkSurfaceKHR*                               pSurface)
4976 {
4977     unique_lock_t lock(global_lock);
4978     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4979     return VK_SUCCESS;
4980 }
4981 #endif /* VK_USE_PLATFORM_FUCHSIA */
4982
4983 #ifdef VK_USE_PLATFORM_METAL_EXT
4984
4985 static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
4986     VkInstance                                  instance,
4987     const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
4988     const VkAllocationCallbacks*                pAllocator,
4989     VkSurfaceKHR*                               pSurface)
4990 {
4991     unique_lock_t lock(global_lock);
4992     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4993     return VK_SUCCESS;
4994 }
4995 #endif /* VK_USE_PLATFORM_METAL_EXT */
4996
4997
4998
4999
5000
5001
5002
5003
5004
5005
5006
5007
5008
5009 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
5010     VkDevice                                    device,
5011     const VkBufferDeviceAddressInfo*            pInfo)
5012 {
5013 //Not a CREATE or DESTROY function
5014     return VK_SUCCESS;
5015 }
5016
5017
5018 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
5019     VkPhysicalDevice                            physicalDevice,
5020     uint32_t*                                   pToolCount,
5021     VkPhysicalDeviceToolProperties*             pToolProperties)
5022 {
5023 //Not a CREATE or DESTROY function
5024     return VK_SUCCESS;
5025 }
5026
5027
5028
5029
5030 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
5031     VkPhysicalDevice                            physicalDevice,
5032     uint32_t*                                   pPropertyCount,
5033     VkCooperativeMatrixPropertiesNV*            pProperties)
5034 {
5035 //Not a CREATE or DESTROY function
5036     return VK_SUCCESS;
5037 }
5038
5039
5040 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
5041     VkPhysicalDevice                            physicalDevice,
5042     uint32_t*                                   pCombinationCount,
5043     VkFramebufferMixedSamplesCombinationNV*     pCombinations)
5044 {
5045 //Not a CREATE or DESTROY function
5046     return VK_SUCCESS;
5047 }
5048
5049
5050
5051
5052 #ifdef VK_USE_PLATFORM_WIN32_KHR
5053
5054 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
5055     VkPhysicalDevice                            physicalDevice,
5056     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5057     uint32_t*                                   pPresentModeCount,
5058     VkPresentModeKHR*                           pPresentModes)
5059 {
5060 //Not a CREATE or DESTROY function
5061     return VK_SUCCESS;
5062 }
5063
5064 static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
5065     VkDevice                                    device,
5066     VkSwapchainKHR                              swapchain)
5067 {
5068 //Not a CREATE or DESTROY function
5069     return VK_SUCCESS;
5070 }
5071
5072 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
5073     VkDevice                                    device,
5074     VkSwapchainKHR                              swapchain)
5075 {
5076 //Not a CREATE or DESTROY function
5077     return VK_SUCCESS;
5078 }
5079
5080 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
5081     VkDevice                                    device,
5082     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5083     VkDeviceGroupPresentModeFlagsKHR*           pModes)
5084 {
5085 //Not a CREATE or DESTROY function
5086     return VK_SUCCESS;
5087 }
5088 #endif /* VK_USE_PLATFORM_WIN32_KHR */
5089
5090
5091 static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
5092     VkInstance                                  instance,
5093     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
5094     const VkAllocationCallbacks*                pAllocator,
5095     VkSurfaceKHR*                               pSurface)
5096 {
5097     unique_lock_t lock(global_lock);
5098     *pSurface = (VkSurfaceKHR)global_unique_handle++;
5099     return VK_SUCCESS;
5100 }
5101
5102
5103 static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
5104     VkCommandBuffer                             commandBuffer,
5105     uint32_t                                    lineStippleFactor,
5106     uint16_t                                    lineStipplePattern)
5107 {
5108 //Not a CREATE or DESTROY function
5109 }
5110
5111
5112
5113 static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
5114     VkDevice                                    device,
5115     VkQueryPool                                 queryPool,
5116     uint32_t                                    firstQuery,
5117     uint32_t                                    queryCount)
5118 {
5119 //Not a CREATE or DESTROY function
5120 }
5121
5122
5123
5124 static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(
5125     VkCommandBuffer                             commandBuffer,
5126     VkCullModeFlags                             cullMode)
5127 {
5128 //Not a CREATE or DESTROY function
5129 }
5130
5131 static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(
5132     VkCommandBuffer                             commandBuffer,
5133     VkFrontFace                                 frontFace)
5134 {
5135 //Not a CREATE or DESTROY function
5136 }
5137
5138 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(
5139     VkCommandBuffer                             commandBuffer,
5140     VkPrimitiveTopology                         primitiveTopology)
5141 {
5142 //Not a CREATE or DESTROY function
5143 }
5144
5145 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(
5146     VkCommandBuffer                             commandBuffer,
5147     uint32_t                                    viewportCount,
5148     const VkViewport*                           pViewports)
5149 {
5150 //Not a CREATE or DESTROY function
5151 }
5152
5153 static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(
5154     VkCommandBuffer                             commandBuffer,
5155     uint32_t                                    scissorCount,
5156     const VkRect2D*                             pScissors)
5157 {
5158 //Not a CREATE or DESTROY function
5159 }
5160
5161 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(
5162     VkCommandBuffer                             commandBuffer,
5163     uint32_t                                    firstBinding,
5164     uint32_t                                    bindingCount,
5165     const VkBuffer*                             pBuffers,
5166     const VkDeviceSize*                         pOffsets,
5167     const VkDeviceSize*                         pSizes,
5168     const VkDeviceSize*                         pStrides)
5169 {
5170 //Not a CREATE or DESTROY function
5171 }
5172
5173 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(
5174     VkCommandBuffer                             commandBuffer,
5175     VkBool32                                    depthTestEnable)
5176 {
5177 //Not a CREATE or DESTROY function
5178 }
5179
5180 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(
5181     VkCommandBuffer                             commandBuffer,
5182     VkBool32                                    depthWriteEnable)
5183 {
5184 //Not a CREATE or DESTROY function
5185 }
5186
5187 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(
5188     VkCommandBuffer                             commandBuffer,
5189     VkCompareOp                                 depthCompareOp)
5190 {
5191 //Not a CREATE or DESTROY function
5192 }
5193
5194 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(
5195     VkCommandBuffer                             commandBuffer,
5196     VkBool32                                    depthBoundsTestEnable)
5197 {
5198 //Not a CREATE or DESTROY function
5199 }
5200
5201 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(
5202     VkCommandBuffer                             commandBuffer,
5203     VkBool32                                    stencilTestEnable)
5204 {
5205 //Not a CREATE or DESTROY function
5206 }
5207
5208 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(
5209     VkCommandBuffer                             commandBuffer,
5210     VkStencilFaceFlags                          faceMask,
5211     VkStencilOp                                 failOp,
5212     VkStencilOp                                 passOp,
5213     VkStencilOp                                 depthFailOp,
5214     VkCompareOp                                 compareOp)
5215 {
5216 //Not a CREATE or DESTROY function
5217 }
5218
5219
5220
5221
5222 static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
5223     VkDevice                                    device,
5224     const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
5225     VkMemoryRequirements2*                      pMemoryRequirements)
5226 {
5227 //Not a CREATE or DESTROY function
5228 }
5229
5230 static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
5231     VkCommandBuffer                             commandBuffer,
5232     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo)
5233 {
5234 //Not a CREATE or DESTROY function
5235 }
5236
5237 static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
5238     VkCommandBuffer                             commandBuffer,
5239     VkBool32                                    isPreprocessed,
5240     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo)
5241 {
5242 //Not a CREATE or DESTROY function
5243 }
5244
5245 static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
5246     VkCommandBuffer                             commandBuffer,
5247     VkPipelineBindPoint                         pipelineBindPoint,
5248     VkPipeline                                  pipeline,
5249     uint32_t                                    groupIndex)
5250 {
5251 //Not a CREATE or DESTROY function
5252 }
5253
5254 static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
5255     VkDevice                                    device,
5256     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
5257     const VkAllocationCallbacks*                pAllocator,
5258     VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout)
5259 {
5260     unique_lock_t lock(global_lock);
5261     *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++;
5262     return VK_SUCCESS;
5263 }
5264
5265 static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
5266     VkDevice                                    device,
5267     VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
5268     const VkAllocationCallbacks*                pAllocator)
5269 {
5270 //Destroy object
5271 }
5272
5273
5274
5275
5276
5277
5278 static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(
5279     VkPhysicalDevice                            physicalDevice,
5280     int32_t                                     drmFd,
5281     VkDisplayKHR                                display)
5282 {
5283 //Not a CREATE or DESTROY function
5284     return VK_SUCCESS;
5285 }
5286
5287 static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(
5288     VkPhysicalDevice                            physicalDevice,
5289     int32_t                                     drmFd,
5290     uint32_t                                    connectorId,
5291     VkDisplayKHR*                               display)
5292 {
5293 //Not a CREATE or DESTROY function
5294     return VK_SUCCESS;
5295 }
5296
5297
5298
5299
5300
5301 static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(
5302     VkDevice                                    device,
5303     const VkPrivateDataSlotCreateInfo*          pCreateInfo,
5304     const VkAllocationCallbacks*                pAllocator,
5305     VkPrivateDataSlot*                          pPrivateDataSlot)
5306 {
5307     unique_lock_t lock(global_lock);
5308     *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++;
5309     return VK_SUCCESS;
5310 }
5311
5312 static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(
5313     VkDevice                                    device,
5314     VkPrivateDataSlot                           privateDataSlot,
5315     const VkAllocationCallbacks*                pAllocator)
5316 {
5317 //Destroy object
5318 }
5319
5320 static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(
5321     VkDevice                                    device,
5322     VkObjectType                                objectType,
5323     uint64_t                                    objectHandle,
5324     VkPrivateDataSlot                           privateDataSlot,
5325     uint64_t                                    data)
5326 {
5327 //Not a CREATE or DESTROY function
5328     return VK_SUCCESS;
5329 }
5330
5331 static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(
5332     VkDevice                                    device,
5333     VkObjectType                                objectType,
5334     uint64_t                                    objectHandle,
5335     VkPrivateDataSlot                           privateDataSlot,
5336     uint64_t*                                   pData)
5337 {
5338 //Not a CREATE or DESTROY function
5339 }
5340
5341
5342
5343
5344
5345 static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(
5346     VkCommandBuffer                             commandBuffer,
5347     VkFragmentShadingRateNV                     shadingRate,
5348     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2])
5349 {
5350 //Not a CREATE or DESTROY function
5351 }
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361 #ifdef VK_USE_PLATFORM_WIN32_KHR
5362
5363 static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(
5364     VkPhysicalDevice                            physicalDevice,
5365     VkDisplayKHR                                display)
5366 {
5367 //Not a CREATE or DESTROY function
5368     return VK_SUCCESS;
5369 }
5370
5371 static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(
5372     VkPhysicalDevice                            physicalDevice,
5373     uint32_t                                    deviceRelativeId,
5374     VkDisplayKHR*                               pDisplay)
5375 {
5376 //Not a CREATE or DESTROY function
5377     return VK_SUCCESS;
5378 }
5379 #endif /* VK_USE_PLATFORM_WIN32_KHR */
5380
5381 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
5382
5383 static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(
5384     VkInstance                                  instance,
5385     const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
5386     const VkAllocationCallbacks*                pAllocator,
5387     VkSurfaceKHR*                               pSurface)
5388 {
5389     unique_lock_t lock(global_lock);
5390     *pSurface = (VkSurfaceKHR)global_unique_handle++;
5391     return VK_SUCCESS;
5392 }
5393
5394 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(
5395     VkPhysicalDevice                            physicalDevice,
5396     uint32_t                                    queueFamilyIndex,
5397     IDirectFB*                                  dfb)
5398 {
5399 //Not a CREATE or DESTROY function
5400     return VK_SUCCESS;
5401 }
5402 #endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
5403
5404
5405
5406 static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(
5407     VkCommandBuffer                             commandBuffer,
5408     uint32_t                                    vertexBindingDescriptionCount,
5409     const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
5410     uint32_t                                    vertexAttributeDescriptionCount,
5411     const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
5412 {
5413 //Not a CREATE or DESTROY function
5414 }
5415
5416
5417
5418
5419 #ifdef VK_USE_PLATFORM_FUCHSIA
5420
5421 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
5422     VkDevice                                    device,
5423     const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
5424     zx_handle_t*                                pZirconHandle)
5425 {
5426 //Not a CREATE or DESTROY function
5427     return VK_SUCCESS;
5428 }
5429
5430 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
5431     VkDevice                                    device,
5432     VkExternalMemoryHandleTypeFlagBits          handleType,
5433     zx_handle_t                                 zirconHandle,
5434     VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties)
5435 {
5436 //Not a CREATE or DESTROY function
5437     return VK_SUCCESS;
5438 }
5439 #endif /* VK_USE_PLATFORM_FUCHSIA */
5440
5441 #ifdef VK_USE_PLATFORM_FUCHSIA
5442
5443 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
5444     VkDevice                                    device,
5445     const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
5446 {
5447 //Not a CREATE or DESTROY function
5448     return VK_SUCCESS;
5449 }
5450
5451 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
5452     VkDevice                                    device,
5453     const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
5454     zx_handle_t*                                pZirconHandle)
5455 {
5456 //Not a CREATE or DESTROY function
5457     return VK_SUCCESS;
5458 }
5459 #endif /* VK_USE_PLATFORM_FUCHSIA */
5460
5461 #ifdef VK_USE_PLATFORM_FUCHSIA
5462
5463 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(
5464     VkDevice                                    device,
5465     const VkBufferCollectionCreateInfoFUCHSIA*  pCreateInfo,
5466     const VkAllocationCallbacks*                pAllocator,
5467     VkBufferCollectionFUCHSIA*                  pCollection)
5468 {
5469     unique_lock_t lock(global_lock);
5470     *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++;
5471     return VK_SUCCESS;
5472 }
5473
5474 static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA(
5475     VkDevice                                    device,
5476     VkBufferCollectionFUCHSIA                   collection,
5477     const VkImageConstraintsInfoFUCHSIA*        pImageConstraintsInfo)
5478 {
5479 //Not a CREATE or DESTROY function
5480     return VK_SUCCESS;
5481 }
5482
5483 static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
5484     VkDevice                                    device,
5485     VkBufferCollectionFUCHSIA                   collection,
5486     const VkBufferConstraintsInfoFUCHSIA*       pBufferConstraintsInfo)
5487 {
5488 //Not a CREATE or DESTROY function
5489     return VK_SUCCESS;
5490 }
5491
5492 static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(
5493     VkDevice                                    device,
5494     VkBufferCollectionFUCHSIA                   collection,
5495     const VkAllocationCallbacks*                pAllocator)
5496 {
5497 //Destroy object
5498 }
5499
5500 static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(
5501     VkDevice                                    device,
5502     VkBufferCollectionFUCHSIA                   collection,
5503     VkBufferCollectionPropertiesFUCHSIA*        pProperties)
5504 {
5505 //Not a CREATE or DESTROY function
5506     return VK_SUCCESS;
5507 }
5508 #endif /* VK_USE_PLATFORM_FUCHSIA */
5509
5510
5511 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
5512     VkDevice                                    device,
5513     VkRenderPass                                renderpass,
5514     VkExtent2D*                                 pMaxWorkgroupSize)
5515 {
5516 //Not a CREATE or DESTROY function
5517     return VK_SUCCESS;
5518 }
5519
5520 static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(
5521     VkCommandBuffer                             commandBuffer)
5522 {
5523 //Not a CREATE or DESTROY function
5524 }
5525
5526
5527 static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(
5528     VkCommandBuffer                             commandBuffer,
5529     VkImageView                                 imageView,
5530     VkImageLayout                               imageLayout)
5531 {
5532 //Not a CREATE or DESTROY function
5533 }
5534
5535
5536 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(
5537     VkDevice                                    device,
5538     const VkMemoryGetRemoteAddressInfoNV*       pMemoryGetRemoteAddressInfo,
5539     VkRemoteAddressNV*                          pAddress)
5540 {
5541 //Not a CREATE or DESTROY function
5542     return VK_SUCCESS;
5543 }
5544
5545
5546 static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(
5547     VkCommandBuffer                             commandBuffer,
5548     uint32_t                                    patchControlPoints)
5549 {
5550 //Not a CREATE or DESTROY function
5551 }
5552
5553 static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(
5554     VkCommandBuffer                             commandBuffer,
5555     VkBool32                                    rasterizerDiscardEnable)
5556 {
5557 //Not a CREATE or DESTROY function
5558 }
5559
5560 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(
5561     VkCommandBuffer                             commandBuffer,
5562     VkBool32                                    depthBiasEnable)
5563 {
5564 //Not a CREATE or DESTROY function
5565 }
5566
5567 static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(
5568     VkCommandBuffer                             commandBuffer,
5569     VkLogicOp                                   logicOp)
5570 {
5571 //Not a CREATE or DESTROY function
5572 }
5573
5574 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(
5575     VkCommandBuffer                             commandBuffer,
5576     VkBool32                                    primitiveRestartEnable)
5577 {
5578 //Not a CREATE or DESTROY function
5579 }
5580
5581 #ifdef VK_USE_PLATFORM_SCREEN_QNX
5582
5583 static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(
5584     VkInstance                                  instance,
5585     const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
5586     const VkAllocationCallbacks*                pAllocator,
5587     VkSurfaceKHR*                               pSurface)
5588 {
5589     unique_lock_t lock(global_lock);
5590     *pSurface = (VkSurfaceKHR)global_unique_handle++;
5591     return VK_SUCCESS;
5592 }
5593
5594 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(
5595     VkPhysicalDevice                            physicalDevice,
5596     uint32_t                                    queueFamilyIndex,
5597     struct _screen_window*                      window)
5598 {
5599 //Not a CREATE or DESTROY function
5600     return VK_SUCCESS;
5601 }
5602 #endif /* VK_USE_PLATFORM_SCREEN_QNX */
5603
5604
5605 static VKAPI_ATTR void                                    VKAPI_CALL CmdSetColorWriteEnableEXT(
5606     VkCommandBuffer                             commandBuffer,
5607     uint32_t                                    attachmentCount,
5608     const VkBool32*                             pColorWriteEnables)
5609 {
5610 //Not a CREATE or DESTROY function
5611 }
5612
5613
5614
5615
5616 static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(
5617     VkCommandBuffer                             commandBuffer,
5618     uint32_t                                    drawCount,
5619     const VkMultiDrawInfoEXT*                   pVertexInfo,
5620     uint32_t                                    instanceCount,
5621     uint32_t                                    firstInstance,
5622     uint32_t                                    stride)
5623 {
5624 //Not a CREATE or DESTROY function
5625 }
5626
5627 static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(
5628     VkCommandBuffer                             commandBuffer,
5629     uint32_t                                    drawCount,
5630     const VkMultiDrawIndexedInfoEXT*            pIndexInfo,
5631     uint32_t                                    instanceCount,
5632     uint32_t                                    firstInstance,
5633     uint32_t                                    stride,
5634     const int32_t*                              pVertexOffset)
5635 {
5636 //Not a CREATE or DESTROY function
5637 }
5638
5639
5640
5641
5642 static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
5643     VkDevice                                    device,
5644     VkDeviceMemory                              memory,
5645     float                                       priority)
5646 {
5647 //Not a CREATE or DESTROY function
5648 }
5649
5650
5651
5652
5653
5654 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
5655     VkDevice                                    device,
5656     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
5657     const VkAllocationCallbacks*                pAllocator,
5658     VkAccelerationStructureKHR*                 pAccelerationStructure)
5659 {
5660     unique_lock_t lock(global_lock);
5661     *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++;
5662     return VK_SUCCESS;
5663 }
5664
5665 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
5666     VkDevice                                    device,
5667     VkAccelerationStructureKHR                  accelerationStructure,
5668     const VkAllocationCallbacks*                pAllocator)
5669 {
5670 //Destroy object
5671 }
5672
5673 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
5674     VkCommandBuffer                             commandBuffer,
5675     uint32_t                                    infoCount,
5676     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
5677     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
5678 {
5679 //Not a CREATE or DESTROY function
5680 }
5681
5682 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
5683     VkCommandBuffer                             commandBuffer,
5684     uint32_t                                    infoCount,
5685     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
5686     const VkDeviceAddress*                      pIndirectDeviceAddresses,
5687     const uint32_t*                             pIndirectStrides,
5688     const uint32_t* const*                      ppMaxPrimitiveCounts)
5689 {
5690 //Not a CREATE or DESTROY function
5691 }
5692
5693 static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR(
5694     VkDevice                                    device,
5695     VkDeferredOperationKHR                      deferredOperation,
5696     uint32_t                                    infoCount,
5697     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
5698     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
5699 {
5700 //Not a CREATE or DESTROY function
5701     return VK_SUCCESS;
5702 }
5703
5704 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(
5705     VkDevice                                    device,
5706     VkDeferredOperationKHR                      deferredOperation,
5707     const VkCopyAccelerationStructureInfoKHR*   pInfo)
5708 {
5709 //Not a CREATE or DESTROY function
5710     return VK_SUCCESS;
5711 }
5712
5713 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
5714     VkDevice                                    device,
5715     VkDeferredOperationKHR                      deferredOperation,
5716     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
5717 {
5718 //Not a CREATE or DESTROY function
5719     return VK_SUCCESS;
5720 }
5721
5722 static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
5723     VkDevice                                    device,
5724     VkDeferredOperationKHR                      deferredOperation,
5725     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
5726 {
5727 //Not a CREATE or DESTROY function
5728     return VK_SUCCESS;
5729 }
5730
5731 static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
5732     VkDevice                                    device,
5733     uint32_t                                    accelerationStructureCount,
5734     const VkAccelerationStructureKHR*           pAccelerationStructures,
5735     VkQueryType                                 queryType,
5736     size_t                                      dataSize,
5737     void*                                       pData,
5738     size_t                                      stride)
5739 {
5740 //Not a CREATE or DESTROY function
5741     return VK_SUCCESS;
5742 }
5743
5744 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
5745     VkCommandBuffer                             commandBuffer,
5746     const VkCopyAccelerationStructureInfoKHR*   pInfo)
5747 {
5748 //Not a CREATE or DESTROY function
5749 }
5750
5751 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
5752     VkCommandBuffer                             commandBuffer,
5753     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
5754 {
5755 //Not a CREATE or DESTROY function
5756 }
5757
5758 static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
5759     VkCommandBuffer                             commandBuffer,
5760     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
5761 {
5762 //Not a CREATE or DESTROY function
5763 }
5764
5765 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
5766     VkDevice                                    device,
5767     const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
5768 {
5769 //Not a CREATE or DESTROY function
5770     return VK_SUCCESS;
5771 }
5772
5773 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
5774     VkCommandBuffer                             commandBuffer,
5775     uint32_t                                    accelerationStructureCount,
5776     const VkAccelerationStructureKHR*           pAccelerationStructures,
5777     VkQueryType                                 queryType,
5778     VkQueryPool                                 queryPool,
5779     uint32_t                                    firstQuery)
5780 {
5781 //Not a CREATE or DESTROY function
5782 }
5783
5784 static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
5785     VkDevice                                    device,
5786     const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
5787     VkAccelerationStructureCompatibilityKHR*    pCompatibility)
5788 {
5789 //Not a CREATE or DESTROY function
5790 }
5791
5792 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
5793     VkDevice                                    device,
5794     VkAccelerationStructureBuildTypeKHR         buildType,
5795     const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
5796     const uint32_t*                             pMaxPrimitiveCounts,
5797     VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo)
5798 {
5799 //Not a CREATE or DESTROY function
5800 }
5801
5802
5803 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
5804     VkCommandBuffer                             commandBuffer,
5805     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
5806     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
5807     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
5808     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
5809     uint32_t                                    width,
5810     uint32_t                                    height,
5811     uint32_t                                    depth)
5812 {
5813 //Not a CREATE or DESTROY function
5814 }
5815
5816 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
5817     VkDevice                                    device,
5818     VkDeferredOperationKHR                      deferredOperation,
5819     VkPipelineCache                             pipelineCache,
5820     uint32_t                                    createInfoCount,
5821     const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
5822     const VkAllocationCallbacks*                pAllocator,
5823     VkPipeline*                                 pPipelines)
5824 {
5825     unique_lock_t lock(global_lock);
5826     for (uint32_t i = 0; i < createInfoCount; ++i) {
5827         pPipelines[i] = (VkPipeline)global_unique_handle++;
5828     }
5829     return VK_SUCCESS;
5830 }
5831
5832 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
5833     VkDevice                                    device,
5834     VkPipeline                                  pipeline,
5835     uint32_t                                    firstGroup,
5836     uint32_t                                    groupCount,
5837     size_t                                      dataSize,
5838     void*                                       pData)
5839 {
5840 //Not a CREATE or DESTROY function
5841     return VK_SUCCESS;
5842 }
5843
5844 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
5845     VkCommandBuffer                             commandBuffer,
5846     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
5847     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
5848     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
5849     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
5850     VkDeviceAddress                             indirectDeviceAddress)
5851 {
5852 //Not a CREATE or DESTROY function
5853 }
5854
5855 static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(
5856     VkDevice                                    device,
5857     VkPipeline                                  pipeline,
5858     uint32_t                                    group,
5859     VkShaderGroupShaderKHR                      groupShader)
5860 {
5861 //Not a CREATE or DESTROY function
5862     return VK_SUCCESS;
5863 }
5864
5865 static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(
5866     VkCommandBuffer                             commandBuffer,
5867     uint32_t                                    pipelineStackSize)
5868 {
5869 //Not a CREATE or DESTROY function
5870 }
5871
5872
5873
5874
5875 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
5876     // TODO: This function should only care about physical device functions and return nullptr for other functions
5877     const auto &item = name_to_funcptr_map.find(funcName);
5878     if (item != name_to_funcptr_map.end()) {
5879         return reinterpret_cast<PFN_vkVoidFunction>(item->second);
5880     }
5881     // Mock should intercept all functions so if we get here just return null
5882     return nullptr;
5883 }
5884
5885 } // namespace vkmock
5886
5887 #if defined(__GNUC__) && __GNUC__ >= 4
5888 #define EXPORT __attribute__((visibility("default")))
5889 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
5890 #define EXPORT __attribute__((visibility("default")))
5891 #else
5892 #define EXPORT
5893 #endif
5894
5895 extern "C" {
5896
5897 EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) {
5898     if (!vkmock::negotiate_loader_icd_interface_called) {
5899         vkmock::loader_interface_version = 1;
5900     }
5901     return vkmock::GetInstanceProcAddr(instance, pName);
5902 }
5903
5904 EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName) {
5905     return vkmock::GetPhysicalDeviceProcAddr(instance, pName);
5906 }
5907
5908 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
5909     vkmock::negotiate_loader_icd_interface_called = true;
5910     vkmock::loader_interface_version = *pSupportedVersion;
5911     if (*pSupportedVersion > vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION) {
5912         *pSupportedVersion = vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION;
5913     }
5914     return VK_SUCCESS;
5915 }
5916
5917
5918 EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
5919     VkInstance                                  instance,
5920     VkSurfaceKHR                                surface,
5921     const VkAllocationCallbacks*                pAllocator)
5922 {
5923     vkmock::DestroySurfaceKHR(instance, surface, pAllocator);
5924 }
5925
5926 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
5927     VkPhysicalDevice                            physicalDevice,
5928     uint32_t                                    queueFamilyIndex,
5929     VkSurfaceKHR                                surface,
5930     VkBool32*                                   pSupported)
5931 {
5932     return vkmock::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
5933 }
5934
5935 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
5936     VkPhysicalDevice                            physicalDevice,
5937     VkSurfaceKHR                                surface,
5938     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities)
5939 {
5940     return vkmock::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
5941 }
5942
5943 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
5944     VkPhysicalDevice                            physicalDevice,
5945     VkSurfaceKHR                                surface,
5946     uint32_t*                                   pSurfaceFormatCount,
5947     VkSurfaceFormatKHR*                         pSurfaceFormats)
5948 {
5949     return vkmock::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
5950 }
5951
5952 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
5953     VkPhysicalDevice                            physicalDevice,
5954     VkSurfaceKHR                                surface,
5955     uint32_t*                                   pPresentModeCount,
5956     VkPresentModeKHR*                           pPresentModes)
5957 {
5958     return vkmock::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
5959 }
5960
5961 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
5962     VkInstance                                  instance,
5963     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
5964     const VkAllocationCallbacks*                pAllocator,
5965     VkSurfaceKHR*                               pSurface)
5966 {
5967     return vkmock::CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
5968 }
5969
5970 #ifdef VK_USE_PLATFORM_XLIB_KHR
5971
5972 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
5973     VkInstance                                  instance,
5974     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
5975     const VkAllocationCallbacks*                pAllocator,
5976     VkSurfaceKHR*                               pSurface)
5977 {
5978     return vkmock::CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
5979 }
5980 #endif /* VK_USE_PLATFORM_XLIB_KHR */
5981
5982 #ifdef VK_USE_PLATFORM_XCB_KHR
5983
5984 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
5985     VkInstance                                  instance,
5986     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
5987     const VkAllocationCallbacks*                pAllocator,
5988     VkSurfaceKHR*                               pSurface)
5989 {
5990     return vkmock::CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
5991 }
5992 #endif /* VK_USE_PLATFORM_XCB_KHR */
5993
5994 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
5995
5996 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
5997     VkInstance                                  instance,
5998     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
5999     const VkAllocationCallbacks*                pAllocator,
6000     VkSurfaceKHR*                               pSurface)
6001 {
6002     return vkmock::CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
6003 }
6004 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
6005
6006 #ifdef VK_USE_PLATFORM_ANDROID_KHR
6007
6008 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
6009     VkInstance                                  instance,
6010     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
6011     const VkAllocationCallbacks*                pAllocator,
6012     VkSurfaceKHR*                               pSurface)
6013 {
6014     return vkmock::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
6015 }
6016 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
6017
6018 #ifdef VK_USE_PLATFORM_WIN32_KHR
6019
6020 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
6021     VkInstance                                  instance,
6022     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
6023     const VkAllocationCallbacks*                pAllocator,
6024     VkSurfaceKHR*                               pSurface)
6025 {
6026     return vkmock::CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
6027 }
6028 #endif /* VK_USE_PLATFORM_WIN32_KHR */
6029
6030 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
6031     VkDevice                                    device,
6032     VkSurfaceKHR                                surface,
6033     VkDeviceGroupPresentModeFlagsKHR*           pModes)
6034 {
6035     return vkmock::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
6036 }
6037
6038 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
6039     VkPhysicalDevice                            physicalDevice,
6040     VkSurfaceKHR                                surface,
6041     uint32_t*                                   pRectCount,
6042     VkRect2D*                                   pRects)
6043 {
6044     return vkmock::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
6045 }
6046
6047 #ifdef VK_USE_PLATFORM_VI_NN
6048
6049 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
6050     VkInstance                                  instance,
6051     const VkViSurfaceCreateInfoNN*              pCreateInfo,
6052     const VkAllocationCallbacks*                pAllocator,
6053     VkSurfaceKHR*                               pSurface)
6054 {
6055     return vkmock::CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
6056 }
6057 #endif /* VK_USE_PLATFORM_VI_NN */
6058
6059 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
6060     VkPhysicalDevice                            physicalDevice,
6061     VkSurfaceKHR                                surface,
6062     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities)
6063 {
6064     return vkmock::GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
6065 }
6066
6067 #ifdef VK_USE_PLATFORM_IOS_MVK
6068
6069 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
6070     VkInstance                                  instance,
6071     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
6072     const VkAllocationCallbacks*                pAllocator,
6073     VkSurfaceKHR*                               pSurface)
6074 {
6075     return vkmock::CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
6076 }
6077 #endif /* VK_USE_PLATFORM_IOS_MVK */
6078
6079 #ifdef VK_USE_PLATFORM_MACOS_MVK
6080
6081 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
6082     VkInstance                                  instance,
6083     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
6084     const VkAllocationCallbacks*                pAllocator,
6085     VkSurfaceKHR*                               pSurface)
6086 {
6087     return vkmock::CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
6088 }
6089 #endif /* VK_USE_PLATFORM_MACOS_MVK */
6090
6091 } // end extern "C"
6092
6093