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 <vector>
  25 #include "vk_typemap_helper.h"
  26 namespace vkmock {
  27
  28
  29 using std::unordered_map;
  30
  31 // Map device memory handle to any mapped allocations that we'll need to free on unmap
  32 static unordered_map<VkDeviceMemory, std::vector<void*>> mapped_memory_map;
  33
  34 static VkPhysicalDevice physical_device = nullptr;
  35 static unordered_map<VkDevice, unordered_map<uint32_t, unordered_map<uint32_t, VkQueue>>> queue_map;
  36 static unordered_map<VkDevice, unordered_map<VkBuffer, VkBufferCreateInfo>> buffer_map;
  37
  38 // TODO: Would like to codegen this but limits aren't in XML
  39 static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits *limits) {
  40     limits->maxImageDimension1D = 4096;
  41     limits->maxImageDimension2D = 4096;
  42     limits->maxImageDimension3D = 256;
  43     limits->maxImageDimensionCube = 4096;
  44     limits->maxImageArrayLayers = 256;
  45     limits->maxTexelBufferElements = 65536;
  46     limits->maxUniformBufferRange = 16384;
  47     limits->maxStorageBufferRange = 134217728;
  48     limits->maxPushConstantsSize = 128;
  49     limits->maxMemoryAllocationCount = 4096;
  50     limits->maxSamplerAllocationCount = 4000;
  51     limits->bufferImageGranularity = 1;
  52     limits->sparseAddressSpaceSize = 2147483648;
  53     limits->maxBoundDescriptorSets = 4;
  54     limits->maxPerStageDescriptorSamplers = 16;
  55     limits->maxPerStageDescriptorUniformBuffers = 12;
  56     limits->maxPerStageDescriptorStorageBuffers = 4;
  57     limits->maxPerStageDescriptorSampledImages = 16;
  58     limits->maxPerStageDescriptorStorageImages = 4;
  59     limits->maxPerStageDescriptorInputAttachments = 4;
  60     limits->maxPerStageResources = 128;
  61     limits->maxDescriptorSetSamplers = 96;
  62     limits->maxDescriptorSetUniformBuffers = 72;
  63     limits->maxDescriptorSetUniformBuffersDynamic = 8;
  64     limits->maxDescriptorSetStorageBuffers = 24;
  65     limits->maxDescriptorSetStorageBuffersDynamic = 4;
  66     limits->maxDescriptorSetSampledImages = 96;
  67     limits->maxDescriptorSetStorageImages = 24;
  68     limits->maxDescriptorSetInputAttachments = 4;
  69     limits->maxVertexInputAttributes = 16;
  70     limits->maxVertexInputBindings = 16;
  71     limits->maxVertexInputAttributeOffset = 2047;
  72     limits->maxVertexInputBindingStride = 2048;
  73     limits->maxVertexOutputComponents = 64;
  74     limits->maxTessellationGenerationLevel = 64;
  75     limits->maxTessellationPatchSize = 32;
  76     limits->maxTessellationControlPerVertexInputComponents = 64;
  77     limits->maxTessellationControlPerVertexOutputComponents = 64;
  78     limits->maxTessellationControlPerPatchOutputComponents = 120;
  79     limits->maxTessellationControlTotalOutputComponents = 2048;
  80     limits->maxTessellationEvaluationInputComponents = 64;
  81     limits->maxTessellationEvaluationOutputComponents = 64;
  82     limits->maxGeometryShaderInvocations = 32;
  83     limits->maxGeometryInputComponents = 64;
  84     limits->maxGeometryOutputComponents = 64;
  85     limits->maxGeometryOutputVertices = 256;
  86     limits->maxGeometryTotalOutputComponents = 1024;
  87     limits->maxFragmentInputComponents = 64;
  88     limits->maxFragmentOutputAttachments = 4;
  89     limits->maxFragmentDualSrcAttachments = 1;
  90     limits->maxFragmentCombinedOutputResources = 4;
  91     limits->maxComputeSharedMemorySize = 16384;
  92     limits->maxComputeWorkGroupCount[0] = 65535;
  93     limits->maxComputeWorkGroupCount[1] = 65535;
  94     limits->maxComputeWorkGroupCount[2] = 65535;
  95     limits->maxComputeWorkGroupInvocations = 128;
  96     limits->maxComputeWorkGroupSize[0] = 128;
  97     limits->maxComputeWorkGroupSize[1] = 128;
  98     limits->maxComputeWorkGroupSize[2] = 64;
  99     limits->subPixelPrecisionBits = 4;
 100     limits->subTexelPrecisionBits = 4;
 101     limits->mipmapPrecisionBits = 4;
 102     limits->maxDrawIndexedIndexValue = UINT32_MAX;
 103     limits->maxDrawIndirectCount = UINT16_MAX;
 104     limits->maxSamplerLodBias = 2.0f;
 105     limits->maxSamplerAnisotropy = 16;
 106     limits->maxViewports = 16;
 107     limits->maxViewportDimensions[0] = 4096;
 108     limits->maxViewportDimensions[1] = 4096;
 109     limits->viewportBoundsRange[0] = -8192;
 110     limits->viewportBoundsRange[1] = 8191;
 111     limits->viewportSubPixelBits = 0;
 112     limits->minMemoryMapAlignment = 64;
 113     limits->minTexelBufferOffsetAlignment = 16;
 114     limits->minUniformBufferOffsetAlignment = 16;
 115     limits->minStorageBufferOffsetAlignment = 16;
 116     limits->minTexelOffset = -8;
 117     limits->maxTexelOffset = 7;
 118     limits->minTexelGatherOffset = -8;
 119     limits->maxTexelGatherOffset = 7;
 120     limits->minInterpolationOffset = 0.0f;
 121     limits->maxInterpolationOffset = 0.5f;
 122     limits->subPixelInterpolationOffsetBits = 4;
 123     limits->maxFramebufferWidth = 4096;
 124     limits->maxFramebufferHeight = 4096;
 125     limits->maxFramebufferLayers = 256;
 126     limits->framebufferColorSampleCounts = 0x7F;
 127     limits->framebufferDepthSampleCounts = 0x7F;
 128     limits->framebufferStencilSampleCounts = 0x7F;
 129     limits->framebufferNoAttachmentsSampleCounts = 0x7F;
 130     limits->maxColorAttachments = 4;
 131     limits->sampledImageColorSampleCounts = 0x7F;
 132     limits->sampledImageIntegerSampleCounts = 0x7F;
 133     limits->sampledImageDepthSampleCounts = 0x7F;
 134     limits->sampledImageStencilSampleCounts = 0x7F;
 135     limits->storageImageSampleCounts = 0x7F;
 136     limits->maxSampleMaskWords = 1;
 137     limits->timestampComputeAndGraphics = VK_TRUE;
 138     limits->timestampPeriod = 1;
 139     limits->maxClipDistances = 8;
 140     limits->maxCullDistances = 8;
 141     limits->maxCombinedClipAndCullDistances = 8;
 142     limits->discreteQueuePriorities = 2;
 143     limits->pointSizeRange[0] = 1.0f;
 144     limits->pointSizeRange[1] = 64.0f;
 145     limits->lineWidthRange[0] = 1.0f;
 146     limits->lineWidthRange[1] = 8.0f;
 147     limits->pointSizeGranularity = 1.0f;
 148     limits->lineWidthGranularity = 1.0f;
 149     limits->strictLines = VK_TRUE;
 150     limits->standardSampleLocations = VK_TRUE;
 151     limits->optimalBufferCopyOffsetAlignment = 1;
 152     limits->optimalBufferCopyRowPitchAlignment = 1;
 153     limits->nonCoherentAtomSize = 256;
 154
 155     return *limits;
 156 }
 157
 158 void SetBoolArrayTrue(VkBool32* bool_array, uint32_t num_bools)
 159 {
 160     for (uint32_t i = 0; i < num_bools; ++i) {
 161         bool_array[i] = VK_TRUE;
 162     }
 163 }
 164
 165
 166
 167 static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
 168     const VkInstanceCreateInfo*                 pCreateInfo,
 169     const VkAllocationCallbacks*                pAllocator,
 170     VkInstance*                                 pInstance)
 171 {
 172
 173     // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with
 174     //  apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the
 175     //  ICD should behave as normal.
 176     if (loader_interface_version <= 4) {
 177         return VK_ERROR_INCOMPATIBLE_DRIVER;
 178     }
 179     *pInstance = (VkInstance)CreateDispObjHandle();
 180     // TODO: If emulating specific device caps, will need to add intelligence here
 181     return VK_SUCCESS;
 182 }
 183
 184 static VKAPI_ATTR void VKAPI_CALL DestroyInstance(
 185     VkInstance                                  instance,
 186     const VkAllocationCallbacks*                pAllocator)
 187 {
 188
 189     // Destroy physical device
 190     DestroyDispObjHandle((void*)physical_device);
 191
 192     DestroyDispObjHandle((void*)instance);
 193 }
 194
 195 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
 196     VkInstance                                  instance,
 197     uint32_t*                                   pPhysicalDeviceCount,
 198     VkPhysicalDevice*                           pPhysicalDevices)
 199 {
 200     if (pPhysicalDevices) {
 201         if (!physical_device) {
 202             physical_device = (VkPhysicalDevice)CreateDispObjHandle();
 203         }
 204         *pPhysicalDevices = physical_device;
 205     } else {
 206         *pPhysicalDeviceCount = 1;
 207     }
 208     return VK_SUCCESS;
 209 }
 210
 211 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
 212     VkPhysicalDevice                            physicalDevice,
 213     VkPhysicalDeviceFeatures*                   pFeatures)
 214 {
 215     uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
 216     VkBool32 *bool_array = &pFeatures->robustBufferAccess;
 217     SetBoolArrayTrue(bool_array, num_bools);
 218 }
 219
 220 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
 221     VkPhysicalDevice                            physicalDevice,
 222     VkFormat                                    format,
 223     VkFormatProperties*                         pFormatProperties)
 224 {
 225     if (VK_FORMAT_UNDEFINED == format) {
 226         *pFormatProperties = { 0x0, 0x0, 0x0 };
 227     } else {
 228         // TODO: Just returning full support for everything initially
 229         *pFormatProperties = { 0x00FFFFFF, 0x00FFFFFF, 0x00FFFFFF };
 230     }
 231 }
 232
 233 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
 234     VkPhysicalDevice                            physicalDevice,
 235     VkFormat                                    format,
 236     VkImageType                                 type,
 237     VkImageTiling                               tiling,
 238     VkImageUsageFlags                           usage,
 239     VkImageCreateFlags                          flags,
 240     VkImageFormatProperties*                    pImageFormatProperties)
 241 {
 242     // A hardcoded unsupported format
 243     if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
 244         return VK_ERROR_FORMAT_NOT_SUPPORTED;
 245     }
 246
 247     // TODO: Just hard-coding some values for now
 248     // TODO: If tiling is linear, limit the mips, levels, & sample count
 249     if (VK_IMAGE_TILING_LINEAR == tiling) {
 250         *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 };
 251     } else {
 252         // We hard-code support for all sample counts except 64 bits.
 253         *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 };
 254     }
 255     return VK_SUCCESS;
 256 }
 257
 258 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
 259     VkPhysicalDevice                            physicalDevice,
 260     VkPhysicalDeviceProperties*                 pProperties)
 261 {
 262     // TODO: Just hard-coding some values for now
 263     pProperties->apiVersion = VK_API_VERSION_1_0;
 264     pProperties->driverVersion = 1;
 265     pProperties->vendorID = 0xba5eba11;
 266     pProperties->deviceID = 0xf005ba11;
 267     pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
 268     //std::string devName = "Vulkan Mock Device";
 269     strcpy(pProperties->deviceName, "Vulkan Mock Device");
 270     pProperties->pipelineCacheUUID[0] = 18;
 271     pProperties->limits = SetLimits(&pProperties->limits);
 272     pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE };
 273 }
 274
 275 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
 276     VkPhysicalDevice                            physicalDevice,
 277     uint32_t*                                   pQueueFamilyPropertyCount,
 278     VkQueueFamilyProperties*                    pQueueFamilyProperties)
 279 {
 280     if (!pQueueFamilyProperties) {
 281         *pQueueFamilyPropertyCount = 1;
 282     } else {
 283         if (*pQueueFamilyPropertyCount) {
 284             pQueueFamilyProperties[0].queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT;
 285             pQueueFamilyProperties[0].queueCount = 1;
 286             pQueueFamilyProperties[0].timestampValidBits = 0;
 287             pQueueFamilyProperties[0].minImageTransferGranularity = {1,1,1};
 288         }
 289     }
 290 }
 291
 292 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
 293     VkPhysicalDevice                            physicalDevice,
 294     VkPhysicalDeviceMemoryProperties*           pMemoryProperties)
 295 {
 296     pMemoryProperties->memoryTypeCount = 2;
 297     pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 298     pMemoryProperties->memoryTypes[0].heapIndex = 0;
 299     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;
 300     pMemoryProperties->memoryTypes[1].heapIndex = 1;
 301     pMemoryProperties->memoryHeapCount = 2;
 302     pMemoryProperties->memoryHeaps[0].flags = 0;
 303     pMemoryProperties->memoryHeaps[0].size = 8000000000;
 304     pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
 305     pMemoryProperties->memoryHeaps[1].size = 8000000000;
 306 }
 307
 308 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
 309     VkInstance                                  instance,
 310     const char*                                 pName)
 311 {
 312
 313     if (!negotiate_loader_icd_interface_called) {
 314         loader_interface_version = 0;
 315     }
 316     const auto &item = name_to_funcptr_map.find(pName);
 317     if (item != name_to_funcptr_map.end()) {
 318         return reinterpret_cast<PFN_vkVoidFunction>(item->second);
 319     }
 320     // Mock should intercept all functions so if we get here just return null
 321     return nullptr;
 322 }
 323
 324 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
 325     VkDevice                                    device,
 326     const char*                                 pName)
 327 {
 328
 329     return GetInstanceProcAddr(nullptr, pName);
 330 }
 331
 332 static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
 333     VkPhysicalDevice                            physicalDevice,
 334     const VkDeviceCreateInfo*                   pCreateInfo,
 335     const VkAllocationCallbacks*                pAllocator,
 336     VkDevice*                                   pDevice)
 337 {
 338
 339     *pDevice = (VkDevice)CreateDispObjHandle();
 340     // TODO: If emulating specific device caps, will need to add intelligence here
 341     return VK_SUCCESS;
 342 }
 343
 344 static VKAPI_ATTR void VKAPI_CALL DestroyDevice(
 345     VkDevice                                    device,
 346     const VkAllocationCallbacks*                pAllocator)
 347 {
 348
 349     unique_lock_t lock(global_lock);
 350     // First destroy sub-device objects
 351     // Destroy Queues
 352     for (auto dev_queue_map_pair : queue_map) {
 353         for (auto queue_family_map_pair : queue_map[dev_queue_map_pair.first]) {
 354             for (auto index_queue_pair : queue_map[dev_queue_map_pair.first][queue_family_map_pair.first]) {
 355                 DestroyDispObjHandle((void*)index_queue_pair.second);
 356             }
 357         }
 358     }
 359     queue_map.clear();
 360     // Now destroy device
 361     DestroyDispObjHandle((void*)device);
 362     // TODO: If emulating specific device caps, will need to add intelligence here
 363 }
 364
 365 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
 366     const char*                                 pLayerName,
 367     uint32_t*                                   pPropertyCount,
 368     VkExtensionProperties*                      pProperties)
 369 {
 370
 371     // If requesting number of extensions, return that
 372     if (!pLayerName) {
 373         if (!pProperties) {
 374             *pPropertyCount = (uint32_t)instance_extension_map.size();
 375         } else {
 376             uint32_t i = 0;
 377             for (const auto &name_ver_pair : instance_extension_map) {
 378                 if (i == *pPropertyCount) {
 379                     break;
 380                 }
 381                 std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
 382                 pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
 383                 pProperties[i].specVersion = name_ver_pair.second;
 384                 ++i;
 385             }
 386             if (i != instance_extension_map.size()) {
 387                 return VK_INCOMPLETE;
 388             }
 389         }
 390     }
 391     // If requesting extension properties, fill in data struct for number of extensions
 392     return VK_SUCCESS;
 393 }
 394
 395 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
 396     VkPhysicalDevice                            physicalDevice,
 397     const char*                                 pLayerName,
 398     uint32_t*                                   pPropertyCount,
 399     VkExtensionProperties*                      pProperties)
 400 {
 401
 402     // If requesting number of extensions, return that
 403     if (!pLayerName) {
 404         if (!pProperties) {
 405             *pPropertyCount = (uint32_t)device_extension_map.size();
 406         } else {
 407             uint32_t i = 0;
 408             for (const auto &name_ver_pair : device_extension_map) {
 409                 if (i == *pPropertyCount) {
 410                     break;
 411                 }
 412                 std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
 413                 pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
 414                 pProperties[i].specVersion = name_ver_pair.second;
 415                 ++i;
 416             }
 417             if (i != device_extension_map.size()) {
 418                 return VK_INCOMPLETE;
 419             }
 420         }
 421     }
 422     // If requesting extension properties, fill in data struct for number of extensions
 423     return VK_SUCCESS;
 424 }
 425
 426 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
 427     uint32_t*                                   pPropertyCount,
 428     VkLayerProperties*                          pProperties)
 429 {
 430
 431     return VK_SUCCESS;
 432 }
 433
 434 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
 435     VkPhysicalDevice                            physicalDevice,
 436     uint32_t*                                   pPropertyCount,
 437     VkLayerProperties*                          pProperties)
 438 {
 439
 440     return VK_SUCCESS;
 441 }
 442
 443 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
 444     VkDevice                                    device,
 445     uint32_t                                    queueFamilyIndex,
 446     uint32_t                                    queueIndex,
 447     VkQueue*                                    pQueue)
 448 {
 449     unique_lock_t lock(global_lock);
 450     auto queue = queue_map[device][queueFamilyIndex][queueIndex];
 451     if (queue) {
 452         *pQueue = queue;
 453     } else {
 454         *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle();
 455     }
 456     // TODO: If emulating specific device caps, will need to add intelligence here
 457     return;
 458 }
 459
 460 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
 461     VkQueue                                     queue,
 462     uint32_t                                    submitCount,
 463     const VkSubmitInfo*                         pSubmits,
 464     VkFence                                     fence)
 465 {
 466 //Not a CREATE or DESTROY function
 467     return VK_SUCCESS;
 468 }
 469
 470 static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
 471     VkQueue                                     queue)
 472 {
 473 //Not a CREATE or DESTROY function
 474     return VK_SUCCESS;
 475 }
 476
 477 static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
 478     VkDevice                                    device)
 479 {
 480 //Not a CREATE or DESTROY function
 481     return VK_SUCCESS;
 482 }
 483
 484 static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
 485     VkDevice                                    device,
 486     const VkMemoryAllocateInfo*                 pAllocateInfo,
 487     const VkAllocationCallbacks*                pAllocator,
 488     VkDeviceMemory*                             pMemory)
 489 {
 490     unique_lock_t lock(global_lock);
 491     *pMemory = (VkDeviceMemory)global_unique_handle++;
 492     return VK_SUCCESS;
 493 }
 494
 495 static VKAPI_ATTR void VKAPI_CALL FreeMemory(
 496     VkDevice                                    device,
 497     VkDeviceMemory                              memory,
 498     const VkAllocationCallbacks*                pAllocator)
 499 {
 500 //Destroy object
 501 }
 502
 503 static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
 504     VkDevice                                    device,
 505     VkDeviceMemory                              memory,
 506     VkDeviceSize                                offset,
 507     VkDeviceSize                                size,
 508     VkMemoryMapFlags                            flags,
 509     void**                                      ppData)
 510 {
 511     unique_lock_t lock(global_lock);
 512     // TODO: Just hard-coding 64k whole size for now
 513     if (VK_WHOLE_SIZE == size)
 514         size = 0x10000;
 515     void* map_addr = malloc((size_t)size);
 516     mapped_memory_map[memory].push_back(map_addr);
 517     *ppData = map_addr;
 518     return VK_SUCCESS;
 519 }
 520
 521 static VKAPI_ATTR void VKAPI_CALL UnmapMemory(
 522     VkDevice                                    device,
 523     VkDeviceMemory                              memory)
 524 {
 525     unique_lock_t lock(global_lock);
 526     for (auto map_addr : mapped_memory_map[memory]) {
 527         free(map_addr);
 528     }
 529     mapped_memory_map.erase(memory);
 530 }
 531
 532 static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
 533     VkDevice                                    device,
 534     uint32_t                                    memoryRangeCount,
 535     const VkMappedMemoryRange*                  pMemoryRanges)
 536 {
 537 //Not a CREATE or DESTROY function
 538     return VK_SUCCESS;
 539 }
 540
 541 static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
 542     VkDevice                                    device,
 543     uint32_t                                    memoryRangeCount,
 544     const VkMappedMemoryRange*                  pMemoryRanges)
 545 {
 546 //Not a CREATE or DESTROY function
 547     return VK_SUCCESS;
 548 }
 549
 550 static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
 551     VkDevice                                    device,
 552     VkDeviceMemory                              memory,
 553     VkDeviceSize*                               pCommittedMemoryInBytes)
 554 {
 555 //Not a CREATE or DESTROY function
 556 }
 557
 558 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
 559     VkDevice                                    device,
 560     VkBuffer                                    buffer,
 561     VkDeviceMemory                              memory,
 562     VkDeviceSize                                memoryOffset)
 563 {
 564 //Not a CREATE or DESTROY function
 565     return VK_SUCCESS;
 566 }
 567
 568 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
 569     VkDevice                                    device,
 570     VkImage                                     image,
 571     VkDeviceMemory                              memory,
 572     VkDeviceSize                                memoryOffset)
 573 {
 574 //Not a CREATE or DESTROY function
 575     return VK_SUCCESS;
 576 }
 577
 578 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
 579     VkDevice                                    device,
 580     VkBuffer                                    buffer,
 581     VkMemoryRequirements*                       pMemoryRequirements)
 582 {
 583     // TODO: Just hard-coding reqs for now
 584     pMemoryRequirements->size = 4096;
 585     pMemoryRequirements->alignment = 1;
 586     pMemoryRequirements->memoryTypeBits = 0xFFFF;
 587     // Return a better size based on the buffer size from the create info.
 588     auto d_iter = buffer_map.find(device);
 589     if (d_iter != buffer_map.end()) {
 590         auto iter = d_iter->second.find(buffer);
 591         if (iter != d_iter->second.end()) {
 592             pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096;
 593         }
 594     }
 595 }
 596
 597 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
 598     VkDevice                                    device,
 599     VkImage                                     image,
 600     VkMemoryRequirements*                       pMemoryRequirements)
 601 {
 602     // TODO: Just hard-coding reqs for now
 603     pMemoryRequirements->size = 4096;
 604     pMemoryRequirements->alignment = 1;
 605
 606     // Here we hard-code that the memory type at index 3 doesn't support this image.
 607     pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3);
 608 }
 609
 610 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
 611     VkDevice                                    device,
 612     VkImage                                     image,
 613     uint32_t*                                   pSparseMemoryRequirementCount,
 614     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements)
 615 {
 616 //Not a CREATE or DESTROY function
 617 }
 618
 619 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
 620     VkPhysicalDevice                            physicalDevice,
 621     VkFormat                                    format,
 622     VkImageType                                 type,
 623     VkSampleCountFlagBits                       samples,
 624     VkImageUsageFlags                           usage,
 625     VkImageTiling                               tiling,
 626     uint32_t*                                   pPropertyCount,
 627     VkSparseImageFormatProperties*              pProperties)
 628 {
 629 //Not a CREATE or DESTROY function
 630 }
 631
 632 static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
 633     VkQueue                                     queue,
 634     uint32_t                                    bindInfoCount,
 635     const VkBindSparseInfo*                     pBindInfo,
 636     VkFence                                     fence)
 637 {
 638 //Not a CREATE or DESTROY function
 639     return VK_SUCCESS;
 640 }
 641
 642 static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
 643     VkDevice                                    device,
 644     const VkFenceCreateInfo*                    pCreateInfo,
 645     const VkAllocationCallbacks*                pAllocator,
 646     VkFence*                                    pFence)
 647 {
 648     unique_lock_t lock(global_lock);
 649     *pFence = (VkFence)global_unique_handle++;
 650     return VK_SUCCESS;
 651 }
 652
 653 static VKAPI_ATTR void VKAPI_CALL DestroyFence(
 654     VkDevice                                    device,
 655     VkFence                                     fence,
 656     const VkAllocationCallbacks*                pAllocator)
 657 {
 658 //Destroy object
 659 }
 660
 661 static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
 662     VkDevice                                    device,
 663     uint32_t                                    fenceCount,
 664     const VkFence*                              pFences)
 665 {
 666 //Not a CREATE or DESTROY function
 667     return VK_SUCCESS;
 668 }
 669
 670 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
 671     VkDevice                                    device,
 672     VkFence                                     fence)
 673 {
 674 //Not a CREATE or DESTROY function
 675     return VK_SUCCESS;
 676 }
 677
 678 static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
 679     VkDevice                                    device,
 680     uint32_t                                    fenceCount,
 681     const VkFence*                              pFences,
 682     VkBool32                                    waitAll,
 683     uint64_t                                    timeout)
 684 {
 685 //Not a CREATE or DESTROY function
 686     return VK_SUCCESS;
 687 }
 688
 689 static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
 690     VkDevice                                    device,
 691     const VkSemaphoreCreateInfo*                pCreateInfo,
 692     const VkAllocationCallbacks*                pAllocator,
 693     VkSemaphore*                                pSemaphore)
 694 {
 695     unique_lock_t lock(global_lock);
 696     *pSemaphore = (VkSemaphore)global_unique_handle++;
 697     return VK_SUCCESS;
 698 }
 699
 700 static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
 701     VkDevice                                    device,
 702     VkSemaphore                                 semaphore,
 703     const VkAllocationCallbacks*                pAllocator)
 704 {
 705 //Destroy object
 706 }
 707
 708 static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
 709     VkDevice                                    device,
 710     const VkEventCreateInfo*                    pCreateInfo,
 711     const VkAllocationCallbacks*                pAllocator,
 712     VkEvent*                                    pEvent)
 713 {
 714     unique_lock_t lock(global_lock);
 715     *pEvent = (VkEvent)global_unique_handle++;
 716     return VK_SUCCESS;
 717 }
 718
 719 static VKAPI_ATTR void VKAPI_CALL DestroyEvent(
 720     VkDevice                                    device,
 721     VkEvent                                     event,
 722     const VkAllocationCallbacks*                pAllocator)
 723 {
 724 //Destroy object
 725 }
 726
 727 static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
 728     VkDevice                                    device,
 729     VkEvent                                     event)
 730 {
 731 //Not a CREATE or DESTROY function
 732     return VK_EVENT_SET;
 733 }
 734
 735 static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
 736     VkDevice                                    device,
 737     VkEvent                                     event)
 738 {
 739 //Not a CREATE or DESTROY function
 740     return VK_SUCCESS;
 741 }
 742
 743 static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
 744     VkDevice                                    device,
 745     VkEvent                                     event)
 746 {
 747 //Not a CREATE or DESTROY function
 748     return VK_SUCCESS;
 749 }
 750
 751 static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
 752     VkDevice                                    device,
 753     const VkQueryPoolCreateInfo*                pCreateInfo,
 754     const VkAllocationCallbacks*                pAllocator,
 755     VkQueryPool*                                pQueryPool)
 756 {
 757     unique_lock_t lock(global_lock);
 758     *pQueryPool = (VkQueryPool)global_unique_handle++;
 759     return VK_SUCCESS;
 760 }
 761
 762 static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
 763     VkDevice                                    device,
 764     VkQueryPool                                 queryPool,
 765     const VkAllocationCallbacks*                pAllocator)
 766 {
 767 //Destroy object
 768 }
 769
 770 static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
 771     VkDevice                                    device,
 772     VkQueryPool                                 queryPool,
 773     uint32_t                                    firstQuery,
 774     uint32_t                                    queryCount,
 775     size_t                                      dataSize,
 776     void*                                       pData,
 777     VkDeviceSize                                stride,
 778     VkQueryResultFlags                          flags)
 779 {
 780 //Not a CREATE or DESTROY function
 781     return VK_SUCCESS;
 782 }
 783
 784 static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
 785     VkDevice                                    device,
 786     const VkBufferCreateInfo*                   pCreateInfo,
 787     const VkAllocationCallbacks*                pAllocator,
 788     VkBuffer*                                   pBuffer)
 789 {
 790     unique_lock_t lock(global_lock);
 791     *pBuffer = (VkBuffer)global_unique_handle++;
 792     buffer_map[device][*pBuffer] = *pCreateInfo;
 793     return VK_SUCCESS;
 794 }
 795
 796 static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
 797     VkDevice                                    device,
 798     VkBuffer                                    buffer,
 799     const VkAllocationCallbacks*                pAllocator)
 800 {
 801     unique_lock_t lock(global_lock);
 802     buffer_map[device].erase(buffer);
 803 }
 804
 805 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
 806     VkDevice                                    device,
 807     const VkBufferViewCreateInfo*               pCreateInfo,
 808     const VkAllocationCallbacks*                pAllocator,
 809     VkBufferView*                               pView)
 810 {
 811     unique_lock_t lock(global_lock);
 812     *pView = (VkBufferView)global_unique_handle++;
 813     return VK_SUCCESS;
 814 }
 815
 816 static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
 817     VkDevice                                    device,
 818     VkBufferView                                bufferView,
 819     const VkAllocationCallbacks*                pAllocator)
 820 {
 821 //Destroy object
 822 }
 823
 824 static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
 825     VkDevice                                    device,
 826     const VkImageCreateInfo*                    pCreateInfo,
 827     const VkAllocationCallbacks*                pAllocator,
 828     VkImage*                                    pImage)
 829 {
 830     unique_lock_t lock(global_lock);
 831     *pImage = (VkImage)global_unique_handle++;
 832     return VK_SUCCESS;
 833 }
 834
 835 static VKAPI_ATTR void VKAPI_CALL DestroyImage(
 836     VkDevice                                    device,
 837     VkImage                                     image,
 838     const VkAllocationCallbacks*                pAllocator)
 839 {
 840 //Destroy object
 841 }
 842
 843 static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
 844     VkDevice                                    device,
 845     VkImage                                     image,
 846     const VkImageSubresource*                   pSubresource,
 847     VkSubresourceLayout*                        pLayout)
 848 {
 849     // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure.
 850     *pLayout = VkSubresourceLayout(); // Default constructor zero values.
 851 }
 852
 853 static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
 854     VkDevice                                    device,
 855     const VkImageViewCreateInfo*                pCreateInfo,
 856     const VkAllocationCallbacks*                pAllocator,
 857     VkImageView*                                pView)
 858 {
 859     unique_lock_t lock(global_lock);
 860     *pView = (VkImageView)global_unique_handle++;
 861     return VK_SUCCESS;
 862 }
 863
 864 static VKAPI_ATTR void VKAPI_CALL DestroyImageView(
 865     VkDevice                                    device,
 866     VkImageView                                 imageView,
 867     const VkAllocationCallbacks*                pAllocator)
 868 {
 869 //Destroy object
 870 }
 871
 872 static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
 873     VkDevice                                    device,
 874     const VkShaderModuleCreateInfo*             pCreateInfo,
 875     const VkAllocationCallbacks*                pAllocator,
 876     VkShaderModule*                             pShaderModule)
 877 {
 878     unique_lock_t lock(global_lock);
 879     *pShaderModule = (VkShaderModule)global_unique_handle++;
 880     return VK_SUCCESS;
 881 }
 882
 883 static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
 884     VkDevice                                    device,
 885     VkShaderModule                              shaderModule,
 886     const VkAllocationCallbacks*                pAllocator)
 887 {
 888 //Destroy object
 889 }
 890
 891 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
 892     VkDevice                                    device,
 893     const VkPipelineCacheCreateInfo*            pCreateInfo,
 894     const VkAllocationCallbacks*                pAllocator,
 895     VkPipelineCache*                            pPipelineCache)
 896 {
 897     unique_lock_t lock(global_lock);
 898     *pPipelineCache = (VkPipelineCache)global_unique_handle++;
 899     return VK_SUCCESS;
 900 }
 901
 902 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
 903     VkDevice                                    device,
 904     VkPipelineCache                             pipelineCache,
 905     const VkAllocationCallbacks*                pAllocator)
 906 {
 907 //Destroy object
 908 }
 909
 910 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
 911     VkDevice                                    device,
 912     VkPipelineCache                             pipelineCache,
 913     size_t*                                     pDataSize,
 914     void*                                       pData)
 915 {
 916 //Not a CREATE or DESTROY function
 917     return VK_SUCCESS;
 918 }
 919
 920 static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
 921     VkDevice                                    device,
 922     VkPipelineCache                             dstCache,
 923     uint32_t                                    srcCacheCount,
 924     const VkPipelineCache*                      pSrcCaches)
 925 {
 926 //Not a CREATE or DESTROY function
 927     return VK_SUCCESS;
 928 }
 929
 930 static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
 931     VkDevice                                    device,
 932     VkPipelineCache                             pipelineCache,
 933     uint32_t                                    createInfoCount,
 934     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
 935     const VkAllocationCallbacks*                pAllocator,
 936     VkPipeline*                                 pPipelines)
 937 {
 938     unique_lock_t lock(global_lock);
 939     for (uint32_t i = 0; i < createInfoCount; ++i) {
 940         pPipelines[i] = (VkPipeline)global_unique_handle++;
 941     }
 942     return VK_SUCCESS;
 943 }
 944
 945 static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
 946     VkDevice                                    device,
 947     VkPipelineCache                             pipelineCache,
 948     uint32_t                                    createInfoCount,
 949     const VkComputePipelineCreateInfo*          pCreateInfos,
 950     const VkAllocationCallbacks*                pAllocator,
 951     VkPipeline*                                 pPipelines)
 952 {
 953     unique_lock_t lock(global_lock);
 954     for (uint32_t i = 0; i < createInfoCount; ++i) {
 955         pPipelines[i] = (VkPipeline)global_unique_handle++;
 956     }
 957     return VK_SUCCESS;
 958 }
 959
 960 static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
 961     VkDevice                                    device,
 962     VkPipeline                                  pipeline,
 963     const VkAllocationCallbacks*                pAllocator)
 964 {
 965 //Destroy object
 966 }
 967
 968 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
 969     VkDevice                                    device,
 970     const VkPipelineLayoutCreateInfo*           pCreateInfo,
 971     const VkAllocationCallbacks*                pAllocator,
 972     VkPipelineLayout*                           pPipelineLayout)
 973 {
 974     unique_lock_t lock(global_lock);
 975     *pPipelineLayout = (VkPipelineLayout)global_unique_handle++;
 976     return VK_SUCCESS;
 977 }
 978
 979 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
 980     VkDevice                                    device,
 981     VkPipelineLayout                            pipelineLayout,
 982     const VkAllocationCallbacks*                pAllocator)
 983 {
 984 //Destroy object
 985 }
 986
 987 static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
 988     VkDevice                                    device,
 989     const VkSamplerCreateInfo*                  pCreateInfo,
 990     const VkAllocationCallbacks*                pAllocator,
 991     VkSampler*                                  pSampler)
 992 {
 993     unique_lock_t lock(global_lock);
 994     *pSampler = (VkSampler)global_unique_handle++;
 995     return VK_SUCCESS;
 996 }
 997
 998 static VKAPI_ATTR void VKAPI_CALL DestroySampler(
 999     VkDevice                                    device,
1000     VkSampler                                   sampler,
1001     const VkAllocationCallbacks*                pAllocator)
1002 {
1003 //Destroy object
1004 }
1005
1006 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
1007     VkDevice                                    device,
1008     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1009     const VkAllocationCallbacks*                pAllocator,
1010     VkDescriptorSetLayout*                      pSetLayout)
1011 {
1012     unique_lock_t lock(global_lock);
1013     *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++;
1014     return VK_SUCCESS;
1015 }
1016
1017 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
1018     VkDevice                                    device,
1019     VkDescriptorSetLayout                       descriptorSetLayout,
1020     const VkAllocationCallbacks*                pAllocator)
1021 {
1022 //Destroy object
1023 }
1024
1025 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
1026     VkDevice                                    device,
1027     const VkDescriptorPoolCreateInfo*           pCreateInfo,
1028     const VkAllocationCallbacks*                pAllocator,
1029     VkDescriptorPool*                           pDescriptorPool)
1030 {
1031     unique_lock_t lock(global_lock);
1032     *pDescriptorPool = (VkDescriptorPool)global_unique_handle++;
1033     return VK_SUCCESS;
1034 }
1035
1036 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
1037     VkDevice                                    device,
1038     VkDescriptorPool                            descriptorPool,
1039     const VkAllocationCallbacks*                pAllocator)
1040 {
1041 //Destroy object
1042 }
1043
1044 static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
1045     VkDevice                                    device,
1046     VkDescriptorPool                            descriptorPool,
1047     VkDescriptorPoolResetFlags                  flags)
1048 {
1049 //Not a CREATE or DESTROY function
1050     return VK_SUCCESS;
1051 }
1052
1053 static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
1054     VkDevice                                    device,
1055     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
1056     VkDescriptorSet*                            pDescriptorSets)
1057 {
1058     unique_lock_t lock(global_lock);
1059     for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
1060         pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++;
1061     }
1062     return VK_SUCCESS;
1063 }
1064
1065 static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
1066     VkDevice                                    device,
1067     VkDescriptorPool                            descriptorPool,
1068     uint32_t                                    descriptorSetCount,
1069     const VkDescriptorSet*                      pDescriptorSets)
1070 {
1071 //Destroy object
1072     return VK_SUCCESS;
1073 }
1074
1075 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
1076     VkDevice                                    device,
1077     uint32_t                                    descriptorWriteCount,
1078     const VkWriteDescriptorSet*                 pDescriptorWrites,
1079     uint32_t                                    descriptorCopyCount,
1080     const VkCopyDescriptorSet*                  pDescriptorCopies)
1081 {
1082 //Not a CREATE or DESTROY function
1083 }
1084
1085 static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
1086     VkDevice                                    device,
1087     const VkFramebufferCreateInfo*              pCreateInfo,
1088     const VkAllocationCallbacks*                pAllocator,
1089     VkFramebuffer*                              pFramebuffer)
1090 {
1091     unique_lock_t lock(global_lock);
1092     *pFramebuffer = (VkFramebuffer)global_unique_handle++;
1093     return VK_SUCCESS;
1094 }
1095
1096 static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
1097     VkDevice                                    device,
1098     VkFramebuffer                               framebuffer,
1099     const VkAllocationCallbacks*                pAllocator)
1100 {
1101 //Destroy object
1102 }
1103
1104 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
1105     VkDevice                                    device,
1106     const VkRenderPassCreateInfo*               pCreateInfo,
1107     const VkAllocationCallbacks*                pAllocator,
1108     VkRenderPass*                               pRenderPass)
1109 {
1110     unique_lock_t lock(global_lock);
1111     *pRenderPass = (VkRenderPass)global_unique_handle++;
1112     return VK_SUCCESS;
1113 }
1114
1115 static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
1116     VkDevice                                    device,
1117     VkRenderPass                                renderPass,
1118     const VkAllocationCallbacks*                pAllocator)
1119 {
1120 //Destroy object
1121 }
1122
1123 static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
1124     VkDevice                                    device,
1125     VkRenderPass                                renderPass,
1126     VkExtent2D*                                 pGranularity)
1127 {
1128 //Not a CREATE or DESTROY function
1129 }
1130
1131 static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
1132     VkDevice                                    device,
1133     const VkCommandPoolCreateInfo*              pCreateInfo,
1134     const VkAllocationCallbacks*                pAllocator,
1135     VkCommandPool*                              pCommandPool)
1136 {
1137     unique_lock_t lock(global_lock);
1138     *pCommandPool = (VkCommandPool)global_unique_handle++;
1139     return VK_SUCCESS;
1140 }
1141
1142 static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
1143     VkDevice                                    device,
1144     VkCommandPool                               commandPool,
1145     const VkAllocationCallbacks*                pAllocator)
1146 {
1147 //Destroy object
1148 }
1149
1150 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
1151     VkDevice                                    device,
1152     VkCommandPool                               commandPool,
1153     VkCommandPoolResetFlags                     flags)
1154 {
1155 //Not a CREATE or DESTROY function
1156     return VK_SUCCESS;
1157 }
1158
1159 static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
1160     VkDevice                                    device,
1161     const VkCommandBufferAllocateInfo*          pAllocateInfo,
1162     VkCommandBuffer*                            pCommandBuffers)
1163 {
1164     unique_lock_t lock(global_lock);
1165     for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
1166         pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle();
1167     }
1168     return VK_SUCCESS;
1169 }
1170
1171 static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
1172     VkDevice                                    device,
1173     VkCommandPool                               commandPool,
1174     uint32_t                                    commandBufferCount,
1175     const VkCommandBuffer*                      pCommandBuffers)
1176 {
1177 //Destroy object
1178 }
1179
1180 static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
1181     VkCommandBuffer                             commandBuffer,
1182     const VkCommandBufferBeginInfo*             pBeginInfo)
1183 {
1184 //Not a CREATE or DESTROY function
1185     return VK_SUCCESS;
1186 }
1187
1188 static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
1189     VkCommandBuffer                             commandBuffer)
1190 {
1191 //Not a CREATE or DESTROY function
1192     return VK_SUCCESS;
1193 }
1194
1195 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
1196     VkCommandBuffer                             commandBuffer,
1197     VkCommandBufferResetFlags                   flags)
1198 {
1199 //Not a CREATE or DESTROY function
1200     return VK_SUCCESS;
1201 }
1202
1203 static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
1204     VkCommandBuffer                             commandBuffer,
1205     VkPipelineBindPoint                         pipelineBindPoint,
1206     VkPipeline                                  pipeline)
1207 {
1208 //Not a CREATE or DESTROY function
1209 }
1210
1211 static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
1212     VkCommandBuffer                             commandBuffer,
1213     uint32_t                                    firstViewport,
1214     uint32_t                                    viewportCount,
1215     const VkViewport*                           pViewports)
1216 {
1217 //Not a CREATE or DESTROY function
1218 }
1219
1220 static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
1221     VkCommandBuffer                             commandBuffer,
1222     uint32_t                                    firstScissor,
1223     uint32_t                                    scissorCount,
1224     const VkRect2D*                             pScissors)
1225 {
1226 //Not a CREATE or DESTROY function
1227 }
1228
1229 static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
1230     VkCommandBuffer                             commandBuffer,
1231     float                                       lineWidth)
1232 {
1233 //Not a CREATE or DESTROY function
1234 }
1235
1236 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
1237     VkCommandBuffer                             commandBuffer,
1238     float                                       depthBiasConstantFactor,
1239     float                                       depthBiasClamp,
1240     float                                       depthBiasSlopeFactor)
1241 {
1242 //Not a CREATE or DESTROY function
1243 }
1244
1245 static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
1246     VkCommandBuffer                             commandBuffer,
1247     const float                                 blendConstants[4])
1248 {
1249 //Not a CREATE or DESTROY function
1250 }
1251
1252 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
1253     VkCommandBuffer                             commandBuffer,
1254     float                                       minDepthBounds,
1255     float                                       maxDepthBounds)
1256 {
1257 //Not a CREATE or DESTROY function
1258 }
1259
1260 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
1261     VkCommandBuffer                             commandBuffer,
1262     VkStencilFaceFlags                          faceMask,
1263     uint32_t                                    compareMask)
1264 {
1265 //Not a CREATE or DESTROY function
1266 }
1267
1268 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
1269     VkCommandBuffer                             commandBuffer,
1270     VkStencilFaceFlags                          faceMask,
1271     uint32_t                                    writeMask)
1272 {
1273 //Not a CREATE or DESTROY function
1274 }
1275
1276 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
1277     VkCommandBuffer                             commandBuffer,
1278     VkStencilFaceFlags                          faceMask,
1279     uint32_t                                    reference)
1280 {
1281 //Not a CREATE or DESTROY function
1282 }
1283
1284 static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
1285     VkCommandBuffer                             commandBuffer,
1286     VkPipelineBindPoint                         pipelineBindPoint,
1287     VkPipelineLayout                            layout,
1288     uint32_t                                    firstSet,
1289     uint32_t                                    descriptorSetCount,
1290     const VkDescriptorSet*                      pDescriptorSets,
1291     uint32_t                                    dynamicOffsetCount,
1292     const uint32_t*                             pDynamicOffsets)
1293 {
1294 //Not a CREATE or DESTROY function
1295 }
1296
1297 static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
1298     VkCommandBuffer                             commandBuffer,
1299     VkBuffer                                    buffer,
1300     VkDeviceSize                                offset,
1301     VkIndexType                                 indexType)
1302 {
1303 //Not a CREATE or DESTROY function
1304 }
1305
1306 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
1307     VkCommandBuffer                             commandBuffer,
1308     uint32_t                                    firstBinding,
1309     uint32_t                                    bindingCount,
1310     const VkBuffer*                             pBuffers,
1311     const VkDeviceSize*                         pOffsets)
1312 {
1313 //Not a CREATE or DESTROY function
1314 }
1315
1316 static VKAPI_ATTR void VKAPI_CALL CmdDraw(
1317     VkCommandBuffer                             commandBuffer,
1318     uint32_t                                    vertexCount,
1319     uint32_t                                    instanceCount,
1320     uint32_t                                    firstVertex,
1321     uint32_t                                    firstInstance)
1322 {
1323 //Not a CREATE or DESTROY function
1324 }
1325
1326 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
1327     VkCommandBuffer                             commandBuffer,
1328     uint32_t                                    indexCount,
1329     uint32_t                                    instanceCount,
1330     uint32_t                                    firstIndex,
1331     int32_t                                     vertexOffset,
1332     uint32_t                                    firstInstance)
1333 {
1334 //Not a CREATE or DESTROY function
1335 }
1336
1337 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
1338     VkCommandBuffer                             commandBuffer,
1339     VkBuffer                                    buffer,
1340     VkDeviceSize                                offset,
1341     uint32_t                                    drawCount,
1342     uint32_t                                    stride)
1343 {
1344 //Not a CREATE or DESTROY function
1345 }
1346
1347 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
1348     VkCommandBuffer                             commandBuffer,
1349     VkBuffer                                    buffer,
1350     VkDeviceSize                                offset,
1351     uint32_t                                    drawCount,
1352     uint32_t                                    stride)
1353 {
1354 //Not a CREATE or DESTROY function
1355 }
1356
1357 static VKAPI_ATTR void VKAPI_CALL CmdDispatch(
1358     VkCommandBuffer                             commandBuffer,
1359     uint32_t                                    groupCountX,
1360     uint32_t                                    groupCountY,
1361     uint32_t                                    groupCountZ)
1362 {
1363 //Not a CREATE or DESTROY function
1364 }
1365
1366 static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
1367     VkCommandBuffer                             commandBuffer,
1368     VkBuffer                                    buffer,
1369     VkDeviceSize                                offset)
1370 {
1371 //Not a CREATE or DESTROY function
1372 }
1373
1374 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
1375     VkCommandBuffer                             commandBuffer,
1376     VkBuffer                                    srcBuffer,
1377     VkBuffer                                    dstBuffer,
1378     uint32_t                                    regionCount,
1379     const VkBufferCopy*                         pRegions)
1380 {
1381 //Not a CREATE or DESTROY function
1382 }
1383
1384 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
1385     VkCommandBuffer                             commandBuffer,
1386     VkImage                                     srcImage,
1387     VkImageLayout                               srcImageLayout,
1388     VkImage                                     dstImage,
1389     VkImageLayout                               dstImageLayout,
1390     uint32_t                                    regionCount,
1391     const VkImageCopy*                          pRegions)
1392 {
1393 //Not a CREATE or DESTROY function
1394 }
1395
1396 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
1397     VkCommandBuffer                             commandBuffer,
1398     VkImage                                     srcImage,
1399     VkImageLayout                               srcImageLayout,
1400     VkImage                                     dstImage,
1401     VkImageLayout                               dstImageLayout,
1402     uint32_t                                    regionCount,
1403     const VkImageBlit*                          pRegions,
1404     VkFilter                                    filter)
1405 {
1406 //Not a CREATE or DESTROY function
1407 }
1408
1409 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
1410     VkCommandBuffer                             commandBuffer,
1411     VkBuffer                                    srcBuffer,
1412     VkImage                                     dstImage,
1413     VkImageLayout                               dstImageLayout,
1414     uint32_t                                    regionCount,
1415     const VkBufferImageCopy*                    pRegions)
1416 {
1417 //Not a CREATE or DESTROY function
1418 }
1419
1420 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
1421     VkCommandBuffer                             commandBuffer,
1422     VkImage                                     srcImage,
1423     VkImageLayout                               srcImageLayout,
1424     VkBuffer                                    dstBuffer,
1425     uint32_t                                    regionCount,
1426     const VkBufferImageCopy*                    pRegions)
1427 {
1428 //Not a CREATE or DESTROY function
1429 }
1430
1431 static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
1432     VkCommandBuffer                             commandBuffer,
1433     VkBuffer                                    dstBuffer,
1434     VkDeviceSize                                dstOffset,
1435     VkDeviceSize                                dataSize,
1436     const void*                                 pData)
1437 {
1438 //Not a CREATE or DESTROY function
1439 }
1440
1441 static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
1442     VkCommandBuffer                             commandBuffer,
1443     VkBuffer                                    dstBuffer,
1444     VkDeviceSize                                dstOffset,
1445     VkDeviceSize                                size,
1446     uint32_t                                    data)
1447 {
1448 //Not a CREATE or DESTROY function
1449 }
1450
1451 static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
1452     VkCommandBuffer                             commandBuffer,
1453     VkImage                                     image,
1454     VkImageLayout                               imageLayout,
1455     const VkClearColorValue*                    pColor,
1456     uint32_t                                    rangeCount,
1457     const VkImageSubresourceRange*              pRanges)
1458 {
1459 //Not a CREATE or DESTROY function
1460 }
1461
1462 static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
1463     VkCommandBuffer                             commandBuffer,
1464     VkImage                                     image,
1465     VkImageLayout                               imageLayout,
1466     const VkClearDepthStencilValue*             pDepthStencil,
1467     uint32_t                                    rangeCount,
1468     const VkImageSubresourceRange*              pRanges)
1469 {
1470 //Not a CREATE or DESTROY function
1471 }
1472
1473 static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
1474     VkCommandBuffer                             commandBuffer,
1475     uint32_t                                    attachmentCount,
1476     const VkClearAttachment*                    pAttachments,
1477     uint32_t                                    rectCount,
1478     const VkClearRect*                          pRects)
1479 {
1480 //Not a CREATE or DESTROY function
1481 }
1482
1483 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
1484     VkCommandBuffer                             commandBuffer,
1485     VkImage                                     srcImage,
1486     VkImageLayout                               srcImageLayout,
1487     VkImage                                     dstImage,
1488     VkImageLayout                               dstImageLayout,
1489     uint32_t                                    regionCount,
1490     const VkImageResolve*                       pRegions)
1491 {
1492 //Not a CREATE or DESTROY function
1493 }
1494
1495 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
1496     VkCommandBuffer                             commandBuffer,
1497     VkEvent                                     event,
1498     VkPipelineStageFlags                        stageMask)
1499 {
1500 //Not a CREATE or DESTROY function
1501 }
1502
1503 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
1504     VkCommandBuffer                             commandBuffer,
1505     VkEvent                                     event,
1506     VkPipelineStageFlags                        stageMask)
1507 {
1508 //Not a CREATE or DESTROY function
1509 }
1510
1511 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
1512     VkCommandBuffer                             commandBuffer,
1513     uint32_t                                    eventCount,
1514     const VkEvent*                              pEvents,
1515     VkPipelineStageFlags                        srcStageMask,
1516     VkPipelineStageFlags                        dstStageMask,
1517     uint32_t                                    memoryBarrierCount,
1518     const VkMemoryBarrier*                      pMemoryBarriers,
1519     uint32_t                                    bufferMemoryBarrierCount,
1520     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
1521     uint32_t                                    imageMemoryBarrierCount,
1522     const VkImageMemoryBarrier*                 pImageMemoryBarriers)
1523 {
1524 //Not a CREATE or DESTROY function
1525 }
1526
1527 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
1528     VkCommandBuffer                             commandBuffer,
1529     VkPipelineStageFlags                        srcStageMask,
1530     VkPipelineStageFlags                        dstStageMask,
1531     VkDependencyFlags                           dependencyFlags,
1532     uint32_t                                    memoryBarrierCount,
1533     const VkMemoryBarrier*                      pMemoryBarriers,
1534     uint32_t                                    bufferMemoryBarrierCount,
1535     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
1536     uint32_t                                    imageMemoryBarrierCount,
1537     const VkImageMemoryBarrier*                 pImageMemoryBarriers)
1538 {
1539 //Not a CREATE or DESTROY function
1540 }
1541
1542 static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
1543     VkCommandBuffer                             commandBuffer,
1544     VkQueryPool                                 queryPool,
1545     uint32_t                                    query,
1546     VkQueryControlFlags                         flags)
1547 {
1548 //Not a CREATE or DESTROY function
1549 }
1550
1551 static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
1552     VkCommandBuffer                             commandBuffer,
1553     VkQueryPool                                 queryPool,
1554     uint32_t                                    query)
1555 {
1556 //Not a CREATE or DESTROY function
1557 }
1558
1559 static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
1560     VkCommandBuffer                             commandBuffer,
1561     VkQueryPool                                 queryPool,
1562     uint32_t                                    firstQuery,
1563     uint32_t                                    queryCount)
1564 {
1565 //Not a CREATE or DESTROY function
1566 }
1567
1568 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
1569     VkCommandBuffer                             commandBuffer,
1570     VkPipelineStageFlagBits                     pipelineStage,
1571     VkQueryPool                                 queryPool,
1572     uint32_t                                    query)
1573 {
1574 //Not a CREATE or DESTROY function
1575 }
1576
1577 static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
1578     VkCommandBuffer                             commandBuffer,
1579     VkQueryPool                                 queryPool,
1580     uint32_t                                    firstQuery,
1581     uint32_t                                    queryCount,
1582     VkBuffer                                    dstBuffer,
1583     VkDeviceSize                                dstOffset,
1584     VkDeviceSize                                stride,
1585     VkQueryResultFlags                          flags)
1586 {
1587 //Not a CREATE or DESTROY function
1588 }
1589
1590 static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
1591     VkCommandBuffer                             commandBuffer,
1592     VkPipelineLayout                            layout,
1593     VkShaderStageFlags                          stageFlags,
1594     uint32_t                                    offset,
1595     uint32_t                                    size,
1596     const void*                                 pValues)
1597 {
1598 //Not a CREATE or DESTROY function
1599 }
1600
1601 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
1602     VkCommandBuffer                             commandBuffer,
1603     const VkRenderPassBeginInfo*                pRenderPassBegin,
1604     VkSubpassContents                           contents)
1605 {
1606 //Not a CREATE or DESTROY function
1607 }
1608
1609 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
1610     VkCommandBuffer                             commandBuffer,
1611     VkSubpassContents                           contents)
1612 {
1613 //Not a CREATE or DESTROY function
1614 }
1615
1616 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
1617     VkCommandBuffer                             commandBuffer)
1618 {
1619 //Not a CREATE or DESTROY function
1620 }
1621
1622 static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
1623     VkCommandBuffer                             commandBuffer,
1624     uint32_t                                    commandBufferCount,
1625     const VkCommandBuffer*                      pCommandBuffers)
1626 {
1627 //Not a CREATE or DESTROY function
1628 }
1629
1630
1631 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(
1632     uint32_t*                                   pApiVersion)
1633 {
1634 //Not a CREATE or DESTROY function
1635     return VK_SUCCESS;
1636 }
1637
1638 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
1639     VkDevice                                    device,
1640     uint32_t                                    bindInfoCount,
1641     const VkBindBufferMemoryInfo*               pBindInfos)
1642 {
1643 //Not a CREATE or DESTROY function
1644     return VK_SUCCESS;
1645 }
1646
1647 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
1648     VkDevice                                    device,
1649     uint32_t                                    bindInfoCount,
1650     const VkBindImageMemoryInfo*                pBindInfos)
1651 {
1652 //Not a CREATE or DESTROY function
1653     return VK_SUCCESS;
1654 }
1655
1656 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
1657     VkDevice                                    device,
1658     uint32_t                                    heapIndex,
1659     uint32_t                                    localDeviceIndex,
1660     uint32_t                                    remoteDeviceIndex,
1661     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures)
1662 {
1663 //Not a CREATE or DESTROY function
1664 }
1665
1666 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
1667     VkCommandBuffer                             commandBuffer,
1668     uint32_t                                    deviceMask)
1669 {
1670 //Not a CREATE or DESTROY function
1671 }
1672
1673 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
1674     VkCommandBuffer                             commandBuffer,
1675     uint32_t                                    baseGroupX,
1676     uint32_t                                    baseGroupY,
1677     uint32_t                                    baseGroupZ,
1678     uint32_t                                    groupCountX,
1679     uint32_t                                    groupCountY,
1680     uint32_t                                    groupCountZ)
1681 {
1682 //Not a CREATE or DESTROY function
1683 }
1684
1685 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
1686     VkInstance                                  instance,
1687     uint32_t*                                   pPhysicalDeviceGroupCount,
1688     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties)
1689 {
1690 //Not a CREATE or DESTROY function
1691     return VK_SUCCESS;
1692 }
1693
1694 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
1695     VkDevice                                    device,
1696     const VkImageMemoryRequirementsInfo2*       pInfo,
1697     VkMemoryRequirements2*                      pMemoryRequirements)
1698 {
1699     GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1700 }
1701
1702 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
1703     VkDevice                                    device,
1704     const VkBufferMemoryRequirementsInfo2*      pInfo,
1705     VkMemoryRequirements2*                      pMemoryRequirements)
1706 {
1707     GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1708 }
1709
1710 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
1711     VkDevice                                    device,
1712     const VkImageSparseMemoryRequirementsInfo2* pInfo,
1713     uint32_t*                                   pSparseMemoryRequirementCount,
1714     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
1715 {
1716 //Not a CREATE or DESTROY function
1717 }
1718
1719 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
1720     VkPhysicalDevice                            physicalDevice,
1721     VkPhysicalDeviceFeatures2*                  pFeatures)
1722 {
1723     GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
1724 }
1725
1726 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
1727     VkPhysicalDevice                            physicalDevice,
1728     VkPhysicalDeviceProperties2*                pProperties)
1729 {
1730     GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
1731 }
1732
1733 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
1734     VkPhysicalDevice                            physicalDevice,
1735     VkFormat                                    format,
1736     VkFormatProperties2*                        pFormatProperties)
1737 {
1738     GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
1739 }
1740
1741 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
1742     VkPhysicalDevice                            physicalDevice,
1743     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
1744     VkImageFormatProperties2*                   pImageFormatProperties)
1745 {
1746     return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
1747 }
1748
1749 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
1750     VkPhysicalDevice                            physicalDevice,
1751     uint32_t*                                   pQueueFamilyPropertyCount,
1752     VkQueueFamilyProperties2*                   pQueueFamilyProperties)
1753 {
1754     GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1755 }
1756
1757 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
1758     VkPhysicalDevice                            physicalDevice,
1759     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties)
1760 {
1761     GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
1762 }
1763
1764 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
1765     VkPhysicalDevice                            physicalDevice,
1766     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1767     uint32_t*                                   pPropertyCount,
1768     VkSparseImageFormatProperties2*             pProperties)
1769 {
1770 //Not a CREATE or DESTROY function
1771 }
1772
1773 static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
1774     VkDevice                                    device,
1775     VkCommandPool                               commandPool,
1776     VkCommandPoolTrimFlags                      flags)
1777 {
1778 //Not a CREATE or DESTROY function
1779 }
1780
1781 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
1782     VkDevice                                    device,
1783     const VkDeviceQueueInfo2*                   pQueueInfo,
1784     VkQueue*                                    pQueue)
1785 {
1786     GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
1787     // TODO: Add further support for GetDeviceQueue2 features
1788 }
1789
1790 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
1791     VkDevice                                    device,
1792     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
1793     const VkAllocationCallbacks*                pAllocator,
1794     VkSamplerYcbcrConversion*                   pYcbcrConversion)
1795 {
1796     unique_lock_t lock(global_lock);
1797     *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
1798     return VK_SUCCESS;
1799 }
1800
1801 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
1802     VkDevice                                    device,
1803     VkSamplerYcbcrConversion                    ycbcrConversion,
1804     const VkAllocationCallbacks*                pAllocator)
1805 {
1806 //Destroy object
1807 }
1808
1809 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
1810     VkDevice                                    device,
1811     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1812     const VkAllocationCallbacks*                pAllocator,
1813     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate)
1814 {
1815     unique_lock_t lock(global_lock);
1816     *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
1817     return VK_SUCCESS;
1818 }
1819
1820 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
1821     VkDevice                                    device,
1822     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1823     const VkAllocationCallbacks*                pAllocator)
1824 {
1825 //Destroy object
1826 }
1827
1828 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
1829     VkDevice                                    device,
1830     VkDescriptorSet                             descriptorSet,
1831     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1832     const void*                                 pData)
1833 {
1834 //Not a CREATE or DESTROY function
1835 }
1836
1837 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
1838     VkPhysicalDevice                            physicalDevice,
1839     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
1840     VkExternalBufferProperties*                 pExternalBufferProperties)
1841 {
1842     // Hard-code support for all handle types and features
1843     pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7;
1844     pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0x1FF;
1845     pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = 0x1FF;
1846 }
1847
1848 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
1849     VkPhysicalDevice                            physicalDevice,
1850     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
1851     VkExternalFenceProperties*                  pExternalFenceProperties)
1852 {
1853     // Hard-code support for all handle types and features
1854     pExternalFenceProperties->exportFromImportedHandleTypes = 0xF;
1855     pExternalFenceProperties->compatibleHandleTypes = 0xF;
1856     pExternalFenceProperties->externalFenceFeatures = 0x3;
1857 }
1858
1859 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
1860     VkPhysicalDevice                            physicalDevice,
1861     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1862     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties)
1863 {
1864     // Hard code support for all handle types and features
1865     pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F;
1866     pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F;
1867     pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3;
1868 }
1869
1870 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
1871     VkDevice                                    device,
1872     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1873     VkDescriptorSetLayoutSupport*               pSupport)
1874 {
1875 //Not a CREATE or DESTROY function
1876 }
1877
1878
1879 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
1880     VkCommandBuffer                             commandBuffer,
1881     VkBuffer                                    buffer,
1882     VkDeviceSize                                offset,
1883     VkBuffer                                    countBuffer,
1884     VkDeviceSize                                countBufferOffset,
1885     uint32_t                                    maxDrawCount,
1886     uint32_t                                    stride)
1887 {
1888 //Not a CREATE or DESTROY function
1889 }
1890
1891 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
1892     VkCommandBuffer                             commandBuffer,
1893     VkBuffer                                    buffer,
1894     VkDeviceSize                                offset,
1895     VkBuffer                                    countBuffer,
1896     VkDeviceSize                                countBufferOffset,
1897     uint32_t                                    maxDrawCount,
1898     uint32_t                                    stride)
1899 {
1900 //Not a CREATE or DESTROY function
1901 }
1902
1903 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
1904     VkDevice                                    device,
1905     const VkRenderPassCreateInfo2*              pCreateInfo,
1906     const VkAllocationCallbacks*                pAllocator,
1907     VkRenderPass*                               pRenderPass)
1908 {
1909     unique_lock_t lock(global_lock);
1910     *pRenderPass = (VkRenderPass)global_unique_handle++;
1911     return VK_SUCCESS;
1912 }
1913
1914 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
1915     VkCommandBuffer                             commandBuffer,
1916     const VkRenderPassBeginInfo*                pRenderPassBegin,
1917     const VkSubpassBeginInfo*                   pSubpassBeginInfo)
1918 {
1919 //Not a CREATE or DESTROY function
1920 }
1921
1922 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
1923     VkCommandBuffer                             commandBuffer,
1924     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
1925     const VkSubpassEndInfo*                     pSubpassEndInfo)
1926 {
1927 //Not a CREATE or DESTROY function
1928 }
1929
1930 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
1931     VkCommandBuffer                             commandBuffer,
1932     const VkSubpassEndInfo*                     pSubpassEndInfo)
1933 {
1934 //Not a CREATE or DESTROY function
1935 }
1936
1937 static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
1938     VkDevice                                    device,
1939     VkQueryPool                                 queryPool,
1940     uint32_t                                    firstQuery,
1941     uint32_t                                    queryCount)
1942 {
1943 //Not a CREATE or DESTROY function
1944 }
1945
1946 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
1947     VkDevice                                    device,
1948     VkSemaphore                                 semaphore,
1949     uint64_t*                                   pValue)
1950 {
1951 //Not a CREATE or DESTROY function
1952     return VK_SUCCESS;
1953 }
1954
1955 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
1956     VkDevice                                    device,
1957     const VkSemaphoreWaitInfo*                  pWaitInfo,
1958     uint64_t                                    timeout)
1959 {
1960 //Not a CREATE or DESTROY function
1961     return VK_SUCCESS;
1962 }
1963
1964 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
1965     VkDevice                                    device,
1966     const VkSemaphoreSignalInfo*                pSignalInfo)
1967 {
1968 //Not a CREATE or DESTROY function
1969     return VK_SUCCESS;
1970 }
1971
1972 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
1973     VkDevice                                    device,
1974     const VkBufferDeviceAddressInfo*            pInfo)
1975 {
1976 //Not a CREATE or DESTROY function
1977     return VK_SUCCESS;
1978 }
1979
1980 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
1981     VkDevice                                    device,
1982     const VkBufferDeviceAddressInfo*            pInfo)
1983 {
1984 //Not a CREATE or DESTROY function
1985     return VK_SUCCESS;
1986 }
1987
1988 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
1989     VkDevice                                    device,
1990     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1991 {
1992 //Not a CREATE or DESTROY function
1993     return VK_SUCCESS;
1994 }
1995
1996
1997 static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
1998     VkInstance                                  instance,
1999     VkSurfaceKHR                                surface,
2000     const VkAllocationCallbacks*                pAllocator)
2001 {
2002 //Destroy object
2003 }
2004
2005 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
2006     VkPhysicalDevice                            physicalDevice,
2007     uint32_t                                    queueFamilyIndex,
2008     VkSurfaceKHR                                surface,
2009     VkBool32*                                   pSupported)
2010 {
2011     // Currently say that all surface/queue combos are supported
2012     *pSupported = VK_TRUE;
2013     return VK_SUCCESS;
2014 }
2015
2016 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
2017     VkPhysicalDevice                            physicalDevice,
2018     VkSurfaceKHR                                surface,
2019     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities)
2020 {
2021     // In general just say max supported is available for requested surface
2022     pSurfaceCapabilities->minImageCount = 1;
2023     pSurfaceCapabilities->maxImageCount = 0;
2024     pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF;
2025     pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF;
2026     pSurfaceCapabilities->minImageExtent.width = 1;
2027     pSurfaceCapabilities->minImageExtent.height = 1;
2028     pSurfaceCapabilities->maxImageExtent.width = 3840;
2029     pSurfaceCapabilities->maxImageExtent.height = 2160;
2030     pSurfaceCapabilities->maxImageArrayLayers = 128;
2031     pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
2032                                                 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
2033                                                 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
2034                                                 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
2035                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
2036                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
2037                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
2038                                                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
2039                                                 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
2040     pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
2041     pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
2042                                                     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR |
2043                                                     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR |
2044                                                     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
2045     pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2046                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
2047                                                 VK_IMAGE_USAGE_SAMPLED_BIT |
2048                                                 VK_IMAGE_USAGE_STORAGE_BIT |
2049                                                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
2050                                                 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
2051                                                 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
2052                                                 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
2053     return VK_SUCCESS;
2054 }
2055
2056 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
2057     VkPhysicalDevice                            physicalDevice,
2058     VkSurfaceKHR                                surface,
2059     uint32_t*                                   pSurfaceFormatCount,
2060     VkSurfaceFormatKHR*                         pSurfaceFormats)
2061 {
2062     // Currently always say that RGBA8 & BGRA8 are supported
2063     if (!pSurfaceFormats) {
2064         *pSurfaceFormatCount = 2;
2065     } else {
2066         // Intentionally falling through and just filling however many types are requested
2067         switch(*pSurfaceFormatCount) {
2068         case 2:
2069             pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM;
2070             pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2071             // fall through
2072         default:
2073             pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM;
2074             pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2075             break;
2076         }
2077     }
2078     return VK_SUCCESS;
2079 }
2080
2081 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
2082     VkPhysicalDevice                            physicalDevice,
2083     VkSurfaceKHR                                surface,
2084     uint32_t*                                   pPresentModeCount,
2085     VkPresentModeKHR*                           pPresentModes)
2086 {
2087     // Currently always say that all present modes are supported
2088     if (!pPresentModes) {
2089         *pPresentModeCount = 6;
2090     } else {
2091         // Intentionally falling through and just filling however many modes are requested
2092         switch(*pPresentModeCount) {
2093         case 6:
2094             pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
2095             // fall through
2096         case 5:
2097             pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
2098             // fall through
2099         case 4:
2100             pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
2101             // fall through
2102         case 3:
2103             pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR;
2104             // fall through
2105         case 2:
2106             pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR;
2107             // fall through
2108         default:
2109             pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
2110             break;
2111         }
2112     }
2113     return VK_SUCCESS;
2114 }
2115
2116
2117 static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
2118     VkDevice                                    device,
2119     const VkSwapchainCreateInfoKHR*             pCreateInfo,
2120     const VkAllocationCallbacks*                pAllocator,
2121     VkSwapchainKHR*                             pSwapchain)
2122 {
2123     unique_lock_t lock(global_lock);
2124     *pSwapchain = (VkSwapchainKHR)global_unique_handle++;
2125     return VK_SUCCESS;
2126 }
2127
2128 static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
2129     VkDevice                                    device,
2130     VkSwapchainKHR                              swapchain,
2131     const VkAllocationCallbacks*                pAllocator)
2132 {
2133 //Destroy object
2134 }
2135
2136 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
2137     VkDevice                                    device,
2138     VkSwapchainKHR                              swapchain,
2139     uint32_t*                                   pSwapchainImageCount,
2140     VkImage*                                    pSwapchainImages)
2141 {
2142     if (!pSwapchainImages) {
2143         *pSwapchainImageCount = 1;
2144     } else if (*pSwapchainImageCount > 0) {
2145         pSwapchainImages[0] = (VkImage)global_unique_handle++;
2146         if (*pSwapchainImageCount != 1) {
2147             return VK_INCOMPLETE;
2148         }
2149     }
2150     return VK_SUCCESS;
2151 }
2152
2153 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
2154     VkDevice                                    device,
2155     VkSwapchainKHR                              swapchain,
2156     uint64_t                                    timeout,
2157     VkSemaphore                                 semaphore,
2158     VkFence                                     fence,
2159     uint32_t*                                   pImageIndex)
2160 {
2161 //Not a CREATE or DESTROY function
2162     return VK_SUCCESS;
2163 }
2164
2165 static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
2166     VkQueue                                     queue,
2167     const VkPresentInfoKHR*                     pPresentInfo)
2168 {
2169 //Not a CREATE or DESTROY function
2170     return VK_SUCCESS;
2171 }
2172
2173 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
2174     VkDevice                                    device,
2175     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities)
2176 {
2177 //Not a CREATE or DESTROY function
2178     return VK_SUCCESS;
2179 }
2180
2181 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
2182     VkDevice                                    device,
2183     VkSurfaceKHR                                surface,
2184     VkDeviceGroupPresentModeFlagsKHR*           pModes)
2185 {
2186 //Not a CREATE or DESTROY function
2187     return VK_SUCCESS;
2188 }
2189
2190 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
2191     VkPhysicalDevice                            physicalDevice,
2192     VkSurfaceKHR                                surface,
2193     uint32_t*                                   pRectCount,
2194     VkRect2D*                                   pRects)
2195 {
2196 //Not a CREATE or DESTROY function
2197     return VK_SUCCESS;
2198 }
2199
2200 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
2201     VkDevice                                    device,
2202     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
2203     uint32_t*                                   pImageIndex)
2204 {
2205 //Not a CREATE or DESTROY function
2206     return VK_SUCCESS;
2207 }
2208
2209
2210 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
2211     VkPhysicalDevice                            physicalDevice,
2212     uint32_t*                                   pPropertyCount,
2213     VkDisplayPropertiesKHR*                     pProperties)
2214 {
2215 //Not a CREATE or DESTROY function
2216     return VK_SUCCESS;
2217 }
2218
2219 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
2220     VkPhysicalDevice                            physicalDevice,
2221     uint32_t*                                   pPropertyCount,
2222     VkDisplayPlanePropertiesKHR*                pProperties)
2223 {
2224 //Not a CREATE or DESTROY function
2225     return VK_SUCCESS;
2226 }
2227
2228 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
2229     VkPhysicalDevice                            physicalDevice,
2230     uint32_t                                    planeIndex,
2231     uint32_t*                                   pDisplayCount,
2232     VkDisplayKHR*                               pDisplays)
2233 {
2234 //Not a CREATE or DESTROY function
2235     return VK_SUCCESS;
2236 }
2237
2238 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
2239     VkPhysicalDevice                            physicalDevice,
2240     VkDisplayKHR                                display,
2241     uint32_t*                                   pPropertyCount,
2242     VkDisplayModePropertiesKHR*                 pProperties)
2243 {
2244 //Not a CREATE or DESTROY function
2245     return VK_SUCCESS;
2246 }
2247
2248 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
2249     VkPhysicalDevice                            physicalDevice,
2250     VkDisplayKHR                                display,
2251     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
2252     const VkAllocationCallbacks*                pAllocator,
2253     VkDisplayModeKHR*                           pMode)
2254 {
2255     unique_lock_t lock(global_lock);
2256     *pMode = (VkDisplayModeKHR)global_unique_handle++;
2257     return VK_SUCCESS;
2258 }
2259
2260 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
2261     VkPhysicalDevice                            physicalDevice,
2262     VkDisplayModeKHR                            mode,
2263     uint32_t                                    planeIndex,
2264     VkDisplayPlaneCapabilitiesKHR*              pCapabilities)
2265 {
2266 //Not a CREATE or DESTROY function
2267     return VK_SUCCESS;
2268 }
2269
2270 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
2271     VkInstance                                  instance,
2272     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
2273     const VkAllocationCallbacks*                pAllocator,
2274     VkSurfaceKHR*                               pSurface)
2275 {
2276     unique_lock_t lock(global_lock);
2277     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2278     return VK_SUCCESS;
2279 }
2280
2281
2282 static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
2283     VkDevice                                    device,
2284     uint32_t                                    swapchainCount,
2285     const VkSwapchainCreateInfoKHR*             pCreateInfos,
2286     const VkAllocationCallbacks*                pAllocator,
2287     VkSwapchainKHR*                             pSwapchains)
2288 {
2289     unique_lock_t lock(global_lock);
2290     for (uint32_t i = 0; i < swapchainCount; ++i) {
2291         pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++;
2292     }
2293     return VK_SUCCESS;
2294 }
2295
2296 #ifdef VK_USE_PLATFORM_XLIB_KHR
2297
2298 static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
2299     VkInstance                                  instance,
2300     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
2301     const VkAllocationCallbacks*                pAllocator,
2302     VkSurfaceKHR*                               pSurface)
2303 {
2304     unique_lock_t lock(global_lock);
2305     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2306     return VK_SUCCESS;
2307 }
2308
2309 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
2310     VkPhysicalDevice                            physicalDevice,
2311     uint32_t                                    queueFamilyIndex,
2312     Display*                                    dpy,
2313     VisualID                                    visualID)
2314 {
2315 //Not a CREATE or DESTROY function
2316     return VK_SUCCESS;
2317 }
2318 #endif /* VK_USE_PLATFORM_XLIB_KHR */
2319
2320 #ifdef VK_USE_PLATFORM_XCB_KHR
2321
2322 static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
2323     VkInstance                                  instance,
2324     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
2325     const VkAllocationCallbacks*                pAllocator,
2326     VkSurfaceKHR*                               pSurface)
2327 {
2328     unique_lock_t lock(global_lock);
2329     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2330     return VK_SUCCESS;
2331 }
2332
2333 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
2334     VkPhysicalDevice                            physicalDevice,
2335     uint32_t                                    queueFamilyIndex,
2336     xcb_connection_t*                           connection,
2337     xcb_visualid_t                              visual_id)
2338 {
2339 //Not a CREATE or DESTROY function
2340     return VK_SUCCESS;
2341 }
2342 #endif /* VK_USE_PLATFORM_XCB_KHR */
2343
2344 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
2345
2346 static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
2347     VkInstance                                  instance,
2348     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
2349     const VkAllocationCallbacks*                pAllocator,
2350     VkSurfaceKHR*                               pSurface)
2351 {
2352     unique_lock_t lock(global_lock);
2353     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2354     return VK_SUCCESS;
2355 }
2356
2357 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
2358     VkPhysicalDevice                            physicalDevice,
2359     uint32_t                                    queueFamilyIndex,
2360     struct wl_display*                          display)
2361 {
2362 //Not a CREATE or DESTROY function
2363     return VK_SUCCESS;
2364 }
2365 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
2366
2367 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2368
2369 static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
2370     VkInstance                                  instance,
2371     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
2372     const VkAllocationCallbacks*                pAllocator,
2373     VkSurfaceKHR*                               pSurface)
2374 {
2375     unique_lock_t lock(global_lock);
2376     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2377     return VK_SUCCESS;
2378 }
2379 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
2380
2381 #ifdef VK_USE_PLATFORM_WIN32_KHR
2382
2383 static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
2384     VkInstance                                  instance,
2385     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
2386     const VkAllocationCallbacks*                pAllocator,
2387     VkSurfaceKHR*                               pSurface)
2388 {
2389     unique_lock_t lock(global_lock);
2390     *pSurface = (VkSurfaceKHR)global_unique_handle++;
2391     return VK_SUCCESS;
2392 }
2393
2394 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
2395     VkPhysicalDevice                            physicalDevice,
2396     uint32_t                                    queueFamilyIndex)
2397 {
2398 //Not a CREATE or DESTROY function
2399     return VK_SUCCESS;
2400 }
2401 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2402
2403
2404
2405
2406 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
2407     VkPhysicalDevice                            physicalDevice,
2408     VkPhysicalDeviceFeatures2*                  pFeatures)
2409 {
2410     GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
2411     uint32_t num_bools = 0; // Count number of VkBool32s in extension structs
2412     VkBool32* feat_bools = nullptr;
2413     const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext);
2414     if (desc_idx_features) {
2415         const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing);
2416         num_bools = bool_size/sizeof(VkBool32);
2417         feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing;
2418         SetBoolArrayTrue(feat_bools, num_bools);
2419     }
2420     const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext);
2421     if (blendop_features) {
2422         const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations);
2423         num_bools = bool_size/sizeof(VkBool32);
2424         feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations;
2425         SetBoolArrayTrue(feat_bools, num_bools);
2426     }
2427 }
2428
2429 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
2430     VkPhysicalDevice                            physicalDevice,
2431     VkPhysicalDeviceProperties2*                pProperties)
2432 {
2433     GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
2434     const auto *desc_idx_props = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingPropertiesEXT>(pProperties->pNext);
2435     if (desc_idx_props) {
2436         VkPhysicalDeviceDescriptorIndexingPropertiesEXT* write_props = (VkPhysicalDeviceDescriptorIndexingPropertiesEXT*)desc_idx_props;
2437         write_props->maxUpdateAfterBindDescriptorsInAllPools = 500000;
2438         write_props->shaderUniformBufferArrayNonUniformIndexingNative = false;
2439         write_props->shaderSampledImageArrayNonUniformIndexingNative = false;
2440         write_props->shaderStorageBufferArrayNonUniformIndexingNative = false;
2441         write_props->shaderStorageImageArrayNonUniformIndexingNative = false;
2442         write_props->shaderInputAttachmentArrayNonUniformIndexingNative = false;
2443         write_props->robustBufferAccessUpdateAfterBind = true;
2444         write_props->quadDivergentImplicitLod = true;
2445         write_props->maxPerStageDescriptorUpdateAfterBindSamplers = 500000;
2446         write_props->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 500000;
2447         write_props->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 500000;
2448         write_props->maxPerStageDescriptorUpdateAfterBindSampledImages = 500000;
2449         write_props->maxPerStageDescriptorUpdateAfterBindStorageImages = 500000;
2450         write_props->maxPerStageDescriptorUpdateAfterBindInputAttachments = 500000;
2451         write_props->maxPerStageUpdateAfterBindResources = 500000;
2452         write_props->maxDescriptorSetUpdateAfterBindSamplers = 500000;
2453         write_props->maxDescriptorSetUpdateAfterBindUniformBuffers = 96;
2454         write_props->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8;
2455         write_props->maxDescriptorSetUpdateAfterBindStorageBuffers = 500000;
2456         write_props->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 4;
2457         write_props->maxDescriptorSetUpdateAfterBindSampledImages = 500000;
2458         write_props->maxDescriptorSetUpdateAfterBindStorageImages = 500000;
2459         write_props->maxDescriptorSetUpdateAfterBindInputAttachments = 500000;
2460     }
2461
2462     const auto *push_descriptor_props = lvl_find_in_chain<VkPhysicalDevicePushDescriptorPropertiesKHR>(pProperties->pNext);
2463     if (push_descriptor_props) {
2464         VkPhysicalDevicePushDescriptorPropertiesKHR* write_props = (VkPhysicalDevicePushDescriptorPropertiesKHR*)push_descriptor_props;
2465         write_props->maxPushDescriptors = 256;
2466     }
2467
2468     const auto *depth_stencil_resolve_props = lvl_find_in_chain<VkPhysicalDeviceDepthStencilResolvePropertiesKHR>(pProperties->pNext);
2469     if (depth_stencil_resolve_props) {
2470         VkPhysicalDeviceDepthStencilResolvePropertiesKHR* write_props = (VkPhysicalDeviceDepthStencilResolvePropertiesKHR*)depth_stencil_resolve_props;
2471         write_props->supportedDepthResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
2472         write_props->supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
2473     }
2474 }
2475
2476 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
2477     VkPhysicalDevice                            physicalDevice,
2478     VkFormat                                    format,
2479     VkFormatProperties2*                        pFormatProperties)
2480 {
2481     GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
2482 }
2483
2484 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
2485     VkPhysicalDevice                            physicalDevice,
2486     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
2487     VkImageFormatProperties2*                   pImageFormatProperties)
2488 {
2489     GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
2490     return VK_SUCCESS;
2491 }
2492
2493 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
2494     VkPhysicalDevice                            physicalDevice,
2495     uint32_t*                                   pQueueFamilyPropertyCount,
2496     VkQueueFamilyProperties2*                   pQueueFamilyProperties)
2497 {
2498     if (pQueueFamilyPropertyCount && pQueueFamilyProperties) {
2499         GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, &pQueueFamilyProperties->queueFamilyProperties);
2500     } else {
2501         GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, nullptr);
2502     }
2503 }
2504
2505 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
2506     VkPhysicalDevice                            physicalDevice,
2507     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties)
2508 {
2509     GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties);
2510 }
2511
2512 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
2513     VkPhysicalDevice                            physicalDevice,
2514     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
2515     uint32_t*                                   pPropertyCount,
2516     VkSparseImageFormatProperties2*             pProperties)
2517 {
2518 //Not a CREATE or DESTROY function
2519 }
2520
2521
2522 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
2523     VkDevice                                    device,
2524     uint32_t                                    heapIndex,
2525     uint32_t                                    localDeviceIndex,
2526     uint32_t                                    remoteDeviceIndex,
2527     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures)
2528 {
2529 //Not a CREATE or DESTROY function
2530 }
2531
2532 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
2533     VkCommandBuffer                             commandBuffer,
2534     uint32_t                                    deviceMask)
2535 {
2536 //Not a CREATE or DESTROY function
2537 }
2538
2539 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
2540     VkCommandBuffer                             commandBuffer,
2541     uint32_t                                    baseGroupX,
2542     uint32_t                                    baseGroupY,
2543     uint32_t                                    baseGroupZ,
2544     uint32_t                                    groupCountX,
2545     uint32_t                                    groupCountY,
2546     uint32_t                                    groupCountZ)
2547 {
2548 //Not a CREATE or DESTROY function
2549 }
2550
2551
2552
2553 static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
2554     VkDevice                                    device,
2555     VkCommandPool                               commandPool,
2556     VkCommandPoolTrimFlags                      flags)
2557 {
2558 //Not a CREATE or DESTROY function
2559 }
2560
2561
2562 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
2563     VkInstance                                  instance,
2564     uint32_t*                                   pPhysicalDeviceGroupCount,
2565     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties)
2566 {
2567 //Not a CREATE or DESTROY function
2568     return VK_SUCCESS;
2569 }
2570
2571
2572 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
2573     VkPhysicalDevice                            physicalDevice,
2574     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
2575     VkExternalBufferProperties*                 pExternalBufferProperties)
2576 {
2577     GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
2578 }
2579
2580
2581 #ifdef VK_USE_PLATFORM_WIN32_KHR
2582
2583 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
2584     VkDevice                                    device,
2585     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
2586     HANDLE*                                     pHandle)
2587 {
2588 //Not a CREATE or DESTROY function
2589     return VK_SUCCESS;
2590 }
2591
2592 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
2593     VkDevice                                    device,
2594     VkExternalMemoryHandleTypeFlagBits          handleType,
2595     HANDLE                                      handle,
2596     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties)
2597 {
2598 //Not a CREATE or DESTROY function
2599     return VK_SUCCESS;
2600 }
2601 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2602
2603
2604 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
2605     VkDevice                                    device,
2606     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
2607     int*                                        pFd)
2608 {
2609 //Not a CREATE or DESTROY function
2610     return VK_SUCCESS;
2611 }
2612
2613 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
2614     VkDevice                                    device,
2615     VkExternalMemoryHandleTypeFlagBits          handleType,
2616     int                                         fd,
2617     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties)
2618 {
2619 //Not a CREATE or DESTROY function
2620     return VK_SUCCESS;
2621 }
2622
2623 #ifdef VK_USE_PLATFORM_WIN32_KHR
2624 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2625
2626
2627 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
2628     VkPhysicalDevice                            physicalDevice,
2629     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
2630     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties)
2631 {
2632     GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
2633 }
2634
2635
2636 #ifdef VK_USE_PLATFORM_WIN32_KHR
2637
2638 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
2639     VkDevice                                    device,
2640     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo)
2641 {
2642 //Not a CREATE or DESTROY function
2643     return VK_SUCCESS;
2644 }
2645
2646 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
2647     VkDevice                                    device,
2648     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
2649     HANDLE*                                     pHandle)
2650 {
2651 //Not a CREATE or DESTROY function
2652     return VK_SUCCESS;
2653 }
2654 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2655
2656
2657 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
2658     VkDevice                                    device,
2659     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo)
2660 {
2661 //Not a CREATE or DESTROY function
2662     return VK_SUCCESS;
2663 }
2664
2665 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
2666     VkDevice                                    device,
2667     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
2668     int*                                        pFd)
2669 {
2670 //Not a CREATE or DESTROY function
2671     return VK_SUCCESS;
2672 }
2673
2674
2675 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
2676     VkCommandBuffer                             commandBuffer,
2677     VkPipelineBindPoint                         pipelineBindPoint,
2678     VkPipelineLayout                            layout,
2679     uint32_t                                    set,
2680     uint32_t                                    descriptorWriteCount,
2681     const VkWriteDescriptorSet*                 pDescriptorWrites)
2682 {
2683 //Not a CREATE or DESTROY function
2684 }
2685
2686 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
2687     VkCommandBuffer                             commandBuffer,
2688     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
2689     VkPipelineLayout                            layout,
2690     uint32_t                                    set,
2691     const void*                                 pData)
2692 {
2693 //Not a CREATE or DESTROY function
2694 }
2695
2696
2697
2698
2699
2700 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
2701     VkDevice                                    device,
2702     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
2703     const VkAllocationCallbacks*                pAllocator,
2704     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate)
2705 {
2706     unique_lock_t lock(global_lock);
2707     *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
2708     return VK_SUCCESS;
2709 }
2710
2711 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
2712     VkDevice                                    device,
2713     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
2714     const VkAllocationCallbacks*                pAllocator)
2715 {
2716 //Destroy object
2717 }
2718
2719 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
2720     VkDevice                                    device,
2721     VkDescriptorSet                             descriptorSet,
2722     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
2723     const void*                                 pData)
2724 {
2725 //Not a CREATE or DESTROY function
2726 }
2727
2728
2729
2730 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
2731     VkDevice                                    device,
2732     const VkRenderPassCreateInfo2*              pCreateInfo,
2733     const VkAllocationCallbacks*                pAllocator,
2734     VkRenderPass*                               pRenderPass)
2735 {
2736     unique_lock_t lock(global_lock);
2737     *pRenderPass = (VkRenderPass)global_unique_handle++;
2738     return VK_SUCCESS;
2739 }
2740
2741 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
2742     VkCommandBuffer                             commandBuffer,
2743     const VkRenderPassBeginInfo*                pRenderPassBegin,
2744     const VkSubpassBeginInfo*                   pSubpassBeginInfo)
2745 {
2746 //Not a CREATE or DESTROY function
2747 }
2748
2749 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
2750     VkCommandBuffer                             commandBuffer,
2751     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
2752     const VkSubpassEndInfo*                     pSubpassEndInfo)
2753 {
2754 //Not a CREATE or DESTROY function
2755 }
2756
2757 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
2758     VkCommandBuffer                             commandBuffer,
2759     const VkSubpassEndInfo*                     pSubpassEndInfo)
2760 {
2761 //Not a CREATE or DESTROY function
2762 }
2763
2764
2765 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
2766     VkDevice                                    device,
2767     VkSwapchainKHR                              swapchain)
2768 {
2769 //Not a CREATE or DESTROY function
2770     return VK_SUCCESS;
2771 }
2772
2773
2774 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
2775     VkPhysicalDevice                            physicalDevice,
2776     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
2777     VkExternalFenceProperties*                  pExternalFenceProperties)
2778 {
2779     GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
2780 }
2781
2782
2783 #ifdef VK_USE_PLATFORM_WIN32_KHR
2784
2785 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
2786     VkDevice                                    device,
2787     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo)
2788 {
2789 //Not a CREATE or DESTROY function
2790     return VK_SUCCESS;
2791 }
2792
2793 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
2794     VkDevice                                    device,
2795     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
2796     HANDLE*                                     pHandle)
2797 {
2798 //Not a CREATE or DESTROY function
2799     return VK_SUCCESS;
2800 }
2801 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2802
2803
2804 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
2805     VkDevice                                    device,
2806     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo)
2807 {
2808 //Not a CREATE or DESTROY function
2809     return VK_SUCCESS;
2810 }
2811
2812 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
2813     VkDevice                                    device,
2814     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
2815     int*                                        pFd)
2816 {
2817 //Not a CREATE or DESTROY function
2818     return VK_SUCCESS;
2819 }
2820
2821
2822 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
2823     VkPhysicalDevice                            physicalDevice,
2824     uint32_t                                    queueFamilyIndex,
2825     uint32_t*                                   pCounterCount,
2826     VkPerformanceCounterKHR*                    pCounters,
2827     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions)
2828 {
2829 //Not a CREATE or DESTROY function
2830     return VK_SUCCESS;
2831 }
2832
2833 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
2834     VkPhysicalDevice                            physicalDevice,
2835     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
2836     uint32_t*                                   pNumPasses)
2837 {
2838 //Not a CREATE or DESTROY function
2839 }
2840
2841 static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
2842     VkDevice                                    device,
2843     const VkAcquireProfilingLockInfoKHR*        pInfo)
2844 {
2845 //Not a CREATE or DESTROY function
2846     return VK_SUCCESS;
2847 }
2848
2849 static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
2850     VkDevice                                    device)
2851 {
2852 //Not a CREATE or DESTROY function
2853 }
2854
2855
2856
2857 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
2858     VkPhysicalDevice                            physicalDevice,
2859     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
2860     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities)
2861 {
2862     GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities);
2863     return VK_SUCCESS;
2864 }
2865
2866 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
2867     VkPhysicalDevice                            physicalDevice,
2868     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
2869     uint32_t*                                   pSurfaceFormatCount,
2870     VkSurfaceFormat2KHR*                        pSurfaceFormats)
2871 {
2872     // Currently always say that RGBA8 & BGRA8 are supported
2873     if (!pSurfaceFormats) {
2874         *pSurfaceFormatCount = 2;
2875     } else {
2876         // Intentionally falling through and just filling however many types are requested
2877         switch(*pSurfaceFormatCount) {
2878         case 2:
2879             pSurfaceFormats[1].pNext = nullptr;
2880             pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
2881             pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2882             // fall through
2883         default:
2884             pSurfaceFormats[1].pNext = nullptr;
2885             pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM;
2886             pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
2887             break;
2888         }
2889     }
2890     return VK_SUCCESS;
2891 }
2892
2893
2894
2895 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
2896     VkPhysicalDevice                            physicalDevice,
2897     uint32_t*                                   pPropertyCount,
2898     VkDisplayProperties2KHR*                    pProperties)
2899 {
2900 //Not a CREATE or DESTROY function
2901     return VK_SUCCESS;
2902 }
2903
2904 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
2905     VkPhysicalDevice                            physicalDevice,
2906     uint32_t*                                   pPropertyCount,
2907     VkDisplayPlaneProperties2KHR*               pProperties)
2908 {
2909 //Not a CREATE or DESTROY function
2910     return VK_SUCCESS;
2911 }
2912
2913 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
2914     VkPhysicalDevice                            physicalDevice,
2915     VkDisplayKHR                                display,
2916     uint32_t*                                   pPropertyCount,
2917     VkDisplayModeProperties2KHR*                pProperties)
2918 {
2919 //Not a CREATE or DESTROY function
2920     return VK_SUCCESS;
2921 }
2922
2923 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
2924     VkPhysicalDevice                            physicalDevice,
2925     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
2926     VkDisplayPlaneCapabilities2KHR*             pCapabilities)
2927 {
2928 //Not a CREATE or DESTROY function
2929     return VK_SUCCESS;
2930 }
2931
2932
2933
2934
2935
2936 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
2937     VkDevice                                    device,
2938     const VkImageMemoryRequirementsInfo2*       pInfo,
2939     VkMemoryRequirements2*                      pMemoryRequirements)
2940 {
2941     GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
2942 }
2943
2944 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
2945     VkDevice                                    device,
2946     const VkBufferMemoryRequirementsInfo2*      pInfo,
2947     VkMemoryRequirements2*                      pMemoryRequirements)
2948 {
2949     GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
2950 }
2951
2952 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
2953     VkDevice                                    device,
2954     const VkImageSparseMemoryRequirementsInfo2* pInfo,
2955     uint32_t*                                   pSparseMemoryRequirementCount,
2956     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements)
2957 {
2958 //Not a CREATE or DESTROY function
2959 }
2960
2961
2962
2963 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
2964     VkDevice                                    device,
2965     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
2966     const VkAllocationCallbacks*                pAllocator,
2967     VkSamplerYcbcrConversion*                   pYcbcrConversion)
2968 {
2969     unique_lock_t lock(global_lock);
2970     *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
2971     return VK_SUCCESS;
2972 }
2973
2974 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
2975     VkDevice                                    device,
2976     VkSamplerYcbcrConversion                    ycbcrConversion,
2977     const VkAllocationCallbacks*                pAllocator)
2978 {
2979 //Destroy object
2980 }
2981
2982
2983 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
2984     VkDevice                                    device,
2985     uint32_t                                    bindInfoCount,
2986     const VkBindBufferMemoryInfo*               pBindInfos)
2987 {
2988 //Not a CREATE or DESTROY function
2989     return VK_SUCCESS;
2990 }
2991
2992 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
2993     VkDevice                                    device,
2994     uint32_t                                    bindInfoCount,
2995     const VkBindImageMemoryInfo*                pBindInfos)
2996 {
2997 //Not a CREATE or DESTROY function
2998     return VK_SUCCESS;
2999 }
3000
3001
3002 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
3003     VkDevice                                    device,
3004     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3005     VkDescriptorSetLayoutSupport*               pSupport)
3006 {
3007 //Not a CREATE or DESTROY function
3008 }
3009
3010
3011 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
3012     VkCommandBuffer                             commandBuffer,
3013     VkBuffer                                    buffer,
3014     VkDeviceSize                                offset,
3015     VkBuffer                                    countBuffer,
3016     VkDeviceSize                                countBufferOffset,
3017     uint32_t                                    maxDrawCount,
3018     uint32_t                                    stride)
3019 {
3020 //Not a CREATE or DESTROY function
3021 }
3022
3023 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
3024     VkCommandBuffer                             commandBuffer,
3025     VkBuffer                                    buffer,
3026     VkDeviceSize                                offset,
3027     VkBuffer                                    countBuffer,
3028     VkDeviceSize                                countBufferOffset,
3029     uint32_t                                    maxDrawCount,
3030     uint32_t                                    stride)
3031 {
3032 //Not a CREATE or DESTROY function
3033 }
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
3045     VkDevice                                    device,
3046     VkSemaphore                                 semaphore,
3047     uint64_t*                                   pValue)
3048 {
3049 //Not a CREATE or DESTROY function
3050     return VK_SUCCESS;
3051 }
3052
3053 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
3054     VkDevice                                    device,
3055     const VkSemaphoreWaitInfo*                  pWaitInfo,
3056     uint64_t                                    timeout)
3057 {
3058 //Not a CREATE or DESTROY function
3059     return VK_SUCCESS;
3060 }
3061
3062 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
3063     VkDevice                                    device,
3064     const VkSemaphoreSignalInfo*                pSignalInfo)
3065 {
3066 //Not a CREATE or DESTROY function
3067     return VK_SUCCESS;
3068 }
3069
3070
3071
3072
3073
3074
3075
3076 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
3077     VkDevice                                    device,
3078     const VkBufferDeviceAddressInfo*            pInfo)
3079 {
3080 //Not a CREATE or DESTROY function
3081     return VK_SUCCESS;
3082 }
3083
3084 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
3085     VkDevice                                    device,
3086     const VkBufferDeviceAddressInfo*            pInfo)
3087 {
3088 //Not a CREATE or DESTROY function
3089     return VK_SUCCESS;
3090 }
3091
3092 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
3093     VkDevice                                    device,
3094     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
3095 {
3096 //Not a CREATE or DESTROY function
3097     return VK_SUCCESS;
3098 }
3099
3100 #ifdef VK_ENABLE_BETA_EXTENSIONS
3101
3102 static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
3103     VkDevice                                    device,
3104     const VkAllocationCallbacks*                pAllocator,
3105     VkDeferredOperationKHR*                     pDeferredOperation)
3106 {
3107     unique_lock_t lock(global_lock);
3108     *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++;
3109     return VK_SUCCESS;
3110 }
3111
3112 static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
3113     VkDevice                                    device,
3114     VkDeferredOperationKHR                      operation,
3115     const VkAllocationCallbacks*                pAllocator)
3116 {
3117 //Destroy object
3118 }
3119
3120 static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
3121     VkDevice                                    device,
3122     VkDeferredOperationKHR                      operation)
3123 {
3124 //Not a CREATE or DESTROY function
3125     return VK_SUCCESS;
3126 }
3127
3128 static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
3129     VkDevice                                    device,
3130     VkDeferredOperationKHR                      operation)
3131 {
3132 //Not a CREATE or DESTROY function
3133     return VK_SUCCESS;
3134 }
3135
3136 static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
3137     VkDevice                                    device,
3138     VkDeferredOperationKHR                      operation)
3139 {
3140 //Not a CREATE or DESTROY function
3141     return VK_SUCCESS;
3142 }
3143 #endif /* VK_ENABLE_BETA_EXTENSIONS */
3144
3145
3146 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
3147     VkDevice                                    device,
3148     const VkPipelineInfoKHR*                    pPipelineInfo,
3149     uint32_t*                                   pExecutableCount,
3150     VkPipelineExecutablePropertiesKHR*          pProperties)
3151 {
3152 //Not a CREATE or DESTROY function
3153     return VK_SUCCESS;
3154 }
3155
3156 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
3157     VkDevice                                    device,
3158     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
3159     uint32_t*                                   pStatisticCount,
3160     VkPipelineExecutableStatisticKHR*           pStatistics)
3161 {
3162 //Not a CREATE or DESTROY function
3163     return VK_SUCCESS;
3164 }
3165
3166 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
3167     VkDevice                                    device,
3168     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
3169     uint32_t*                                   pInternalRepresentationCount,
3170     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
3171 {
3172 //Not a CREATE or DESTROY function
3173     return VK_SUCCESS;
3174 }
3175
3176 #ifdef VK_ENABLE_BETA_EXTENSIONS
3177 #endif /* VK_ENABLE_BETA_EXTENSIONS */
3178
3179
3180
3181 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
3182     VkInstance                                  instance,
3183     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
3184     const VkAllocationCallbacks*                pAllocator,
3185     VkDebugReportCallbackEXT*                   pCallback)
3186 {
3187     unique_lock_t lock(global_lock);
3188     *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++;
3189     return VK_SUCCESS;
3190 }
3191
3192 static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
3193     VkInstance                                  instance,
3194     VkDebugReportCallbackEXT                    callback,
3195     const VkAllocationCallbacks*                pAllocator)
3196 {
3197 //Destroy object
3198 }
3199
3200 static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
3201     VkInstance                                  instance,
3202     VkDebugReportFlagsEXT                       flags,
3203     VkDebugReportObjectTypeEXT                  objectType,
3204     uint64_t                                    object,
3205     size_t                                      location,
3206     int32_t                                     messageCode,
3207     const char*                                 pLayerPrefix,
3208     const char*                                 pMessage)
3209 {
3210 //Not a CREATE or DESTROY function
3211 }
3212
3213
3214
3215
3216
3217
3218
3219
3220 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
3221     VkDevice                                    device,
3222     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo)
3223 {
3224 //Not a CREATE or DESTROY function
3225     return VK_SUCCESS;
3226 }
3227
3228 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
3229     VkDevice                                    device,
3230     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo)
3231 {
3232 //Not a CREATE or DESTROY function
3233     return VK_SUCCESS;
3234 }
3235
3236 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
3237     VkCommandBuffer                             commandBuffer,
3238     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo)
3239 {
3240 //Not a CREATE or DESTROY function
3241 }
3242
3243 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
3244     VkCommandBuffer                             commandBuffer)
3245 {
3246 //Not a CREATE or DESTROY function
3247 }
3248
3249 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
3250     VkCommandBuffer                             commandBuffer,
3251     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo)
3252 {
3253 //Not a CREATE or DESTROY function
3254 }
3255
3256
3257
3258
3259 static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
3260     VkCommandBuffer                             commandBuffer,
3261     uint32_t                                    firstBinding,
3262     uint32_t                                    bindingCount,
3263     const VkBuffer*                             pBuffers,
3264     const VkDeviceSize*                         pOffsets,
3265     const VkDeviceSize*                         pSizes)
3266 {
3267 //Not a CREATE or DESTROY function
3268 }
3269
3270 static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
3271     VkCommandBuffer                             commandBuffer,
3272     uint32_t                                    firstCounterBuffer,
3273     uint32_t                                    counterBufferCount,
3274     const VkBuffer*                             pCounterBuffers,
3275     const VkDeviceSize*                         pCounterBufferOffsets)
3276 {
3277 //Not a CREATE or DESTROY function
3278 }
3279
3280 static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
3281     VkCommandBuffer                             commandBuffer,
3282     uint32_t                                    firstCounterBuffer,
3283     uint32_t                                    counterBufferCount,
3284     const VkBuffer*                             pCounterBuffers,
3285     const VkDeviceSize*                         pCounterBufferOffsets)
3286 {
3287 //Not a CREATE or DESTROY function
3288 }
3289
3290 static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
3291     VkCommandBuffer                             commandBuffer,
3292     VkQueryPool                                 queryPool,
3293     uint32_t                                    query,
3294     VkQueryControlFlags                         flags,
3295     uint32_t                                    index)
3296 {
3297 //Not a CREATE or DESTROY function
3298 }
3299
3300 static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
3301     VkCommandBuffer                             commandBuffer,
3302     VkQueryPool                                 queryPool,
3303     uint32_t                                    query,
3304     uint32_t                                    index)
3305 {
3306 //Not a CREATE or DESTROY function
3307 }
3308
3309 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
3310     VkCommandBuffer                             commandBuffer,
3311     uint32_t                                    instanceCount,
3312     uint32_t                                    firstInstance,
3313     VkBuffer                                    counterBuffer,
3314     VkDeviceSize                                counterBufferOffset,
3315     uint32_t                                    counterOffset,
3316     uint32_t                                    vertexStride)
3317 {
3318 //Not a CREATE or DESTROY function
3319 }
3320
3321
3322 static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
3323     VkDevice                                    device,
3324     const VkImageViewHandleInfoNVX*             pInfo)
3325 {
3326 //Not a CREATE or DESTROY function
3327     return VK_SUCCESS;
3328 }
3329
3330
3331 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
3332     VkCommandBuffer                             commandBuffer,
3333     VkBuffer                                    buffer,
3334     VkDeviceSize                                offset,
3335     VkBuffer                                    countBuffer,
3336     VkDeviceSize                                countBufferOffset,
3337     uint32_t                                    maxDrawCount,
3338     uint32_t                                    stride)
3339 {
3340 //Not a CREATE or DESTROY function
3341 }
3342
3343 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
3344     VkCommandBuffer                             commandBuffer,
3345     VkBuffer                                    buffer,
3346     VkDeviceSize                                offset,
3347     VkBuffer                                    countBuffer,
3348     VkDeviceSize                                countBufferOffset,
3349     uint32_t                                    maxDrawCount,
3350     uint32_t                                    stride)
3351 {
3352 //Not a CREATE or DESTROY function
3353 }
3354
3355
3356
3357
3358
3359
3360 static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
3361     VkDevice                                    device,
3362     VkPipeline                                  pipeline,
3363     VkShaderStageFlagBits                       shaderStage,
3364     VkShaderInfoTypeAMD                         infoType,
3365     size_t*                                     pInfoSize,
3366     void*                                       pInfo)
3367 {
3368 //Not a CREATE or DESTROY function
3369     return VK_SUCCESS;
3370 }
3371
3372
3373 #ifdef VK_USE_PLATFORM_GGP
3374
3375 static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
3376     VkInstance                                  instance,
3377     const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
3378     const VkAllocationCallbacks*                pAllocator,
3379     VkSurfaceKHR*                               pSurface)
3380 {
3381     unique_lock_t lock(global_lock);
3382     *pSurface = (VkSurfaceKHR)global_unique_handle++;
3383     return VK_SUCCESS;
3384 }
3385 #endif /* VK_USE_PLATFORM_GGP */
3386
3387
3388
3389
3390 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
3391     VkPhysicalDevice                            physicalDevice,
3392     VkFormat                                    format,
3393     VkImageType                                 type,
3394     VkImageTiling                               tiling,
3395     VkImageUsageFlags                           usage,
3396     VkImageCreateFlags                          flags,
3397     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
3398     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties)
3399 {
3400 //Not a CREATE or DESTROY function
3401     return VK_SUCCESS;
3402 }
3403
3404
3405 #ifdef VK_USE_PLATFORM_WIN32_KHR
3406
3407 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
3408     VkDevice                                    device,
3409     VkDeviceMemory                              memory,
3410     VkExternalMemoryHandleTypeFlagsNV           handleType,
3411     HANDLE*                                     pHandle)
3412 {
3413 //Not a CREATE or DESTROY function
3414     return VK_SUCCESS;
3415 }
3416 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3417
3418 #ifdef VK_USE_PLATFORM_WIN32_KHR
3419 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3420
3421
3422 #ifdef VK_USE_PLATFORM_VI_NN
3423
3424 static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
3425     VkInstance                                  instance,
3426     const VkViSurfaceCreateInfoNN*              pCreateInfo,
3427     const VkAllocationCallbacks*                pAllocator,
3428     VkSurfaceKHR*                               pSurface)
3429 {
3430     unique_lock_t lock(global_lock);
3431     *pSurface = (VkSurfaceKHR)global_unique_handle++;
3432     return VK_SUCCESS;
3433 }
3434 #endif /* VK_USE_PLATFORM_VI_NN */
3435
3436
3437
3438
3439
3440
3441 static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
3442     VkCommandBuffer                             commandBuffer,
3443     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin)
3444 {
3445 //Not a CREATE or DESTROY function
3446 }
3447
3448 static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
3449     VkCommandBuffer                             commandBuffer)
3450 {
3451 //Not a CREATE or DESTROY function
3452 }
3453
3454
3455 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
3456     VkCommandBuffer                             commandBuffer,
3457     uint32_t                                    firstViewport,
3458     uint32_t                                    viewportCount,
3459     const VkViewportWScalingNV*                 pViewportWScalings)
3460 {
3461 //Not a CREATE or DESTROY function
3462 }
3463
3464
3465 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
3466     VkPhysicalDevice                            physicalDevice,
3467     VkDisplayKHR                                display)
3468 {
3469 //Not a CREATE or DESTROY function
3470     return VK_SUCCESS;
3471 }
3472
3473 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3474
3475 static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
3476     VkPhysicalDevice                            physicalDevice,
3477     Display*                                    dpy,
3478     VkDisplayKHR                                display)
3479 {
3480 //Not a CREATE or DESTROY function
3481     return VK_SUCCESS;
3482 }
3483
3484 static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
3485     VkPhysicalDevice                            physicalDevice,
3486     Display*                                    dpy,
3487     RROutput                                    rrOutput,
3488     VkDisplayKHR*                               pDisplay)
3489 {
3490 //Not a CREATE or DESTROY function
3491     return VK_SUCCESS;
3492 }
3493 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
3494
3495
3496 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
3497     VkPhysicalDevice                            physicalDevice,
3498     VkSurfaceKHR                                surface,
3499     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities)
3500 {
3501 //Not a CREATE or DESTROY function
3502     return VK_SUCCESS;
3503 }
3504
3505
3506 static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
3507     VkDevice                                    device,
3508     VkDisplayKHR                                display,
3509     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo)
3510 {
3511 //Not a CREATE or DESTROY function
3512     return VK_SUCCESS;
3513 }
3514
3515 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
3516     VkDevice                                    device,
3517     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
3518     const VkAllocationCallbacks*                pAllocator,
3519     VkFence*                                    pFence)
3520 {
3521 //Not a CREATE or DESTROY function
3522     return VK_SUCCESS;
3523 }
3524
3525 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
3526     VkDevice                                    device,
3527     VkDisplayKHR                                display,
3528     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
3529     const VkAllocationCallbacks*                pAllocator,
3530     VkFence*                                    pFence)
3531 {
3532 //Not a CREATE or DESTROY function
3533     return VK_SUCCESS;
3534 }
3535
3536 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
3537     VkDevice                                    device,
3538     VkSwapchainKHR                              swapchain,
3539     VkSurfaceCounterFlagBitsEXT                 counter,
3540     uint64_t*                                   pCounterValue)
3541 {
3542 //Not a CREATE or DESTROY function
3543     return VK_SUCCESS;
3544 }
3545
3546
3547 static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
3548     VkDevice                                    device,
3549     VkSwapchainKHR                              swapchain,
3550     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties)
3551 {
3552 //Not a CREATE or DESTROY function
3553     return VK_SUCCESS;
3554 }
3555
3556 static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
3557     VkDevice                                    device,
3558     VkSwapchainKHR                              swapchain,
3559     uint32_t*                                   pPresentationTimingCount,
3560     VkPastPresentationTimingGOOGLE*             pPresentationTimings)
3561 {
3562 //Not a CREATE or DESTROY function
3563     return VK_SUCCESS;
3564 }
3565
3566
3567
3568
3569
3570
3571
3572 static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
3573     VkCommandBuffer                             commandBuffer,
3574     uint32_t                                    firstDiscardRectangle,
3575     uint32_t                                    discardRectangleCount,
3576     const VkRect2D*                             pDiscardRectangles)
3577 {
3578 //Not a CREATE or DESTROY function
3579 }
3580
3581
3582
3583
3584
3585 static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
3586     VkDevice                                    device,
3587     uint32_t                                    swapchainCount,
3588     const VkSwapchainKHR*                       pSwapchains,
3589     const VkHdrMetadataEXT*                     pMetadata)
3590 {
3591 //Not a CREATE or DESTROY function
3592 }
3593
3594 #ifdef VK_USE_PLATFORM_IOS_MVK
3595
3596 static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
3597     VkInstance                                  instance,
3598     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
3599     const VkAllocationCallbacks*                pAllocator,
3600     VkSurfaceKHR*                               pSurface)
3601 {
3602     unique_lock_t lock(global_lock);
3603     *pSurface = (VkSurfaceKHR)global_unique_handle++;
3604     return VK_SUCCESS;
3605 }
3606 #endif /* VK_USE_PLATFORM_IOS_MVK */
3607
3608 #ifdef VK_USE_PLATFORM_MACOS_MVK
3609
3610 static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
3611     VkInstance                                  instance,
3612     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
3613     const VkAllocationCallbacks*                pAllocator,
3614     VkSurfaceKHR*                               pSurface)
3615 {
3616     unique_lock_t lock(global_lock);
3617     *pSurface = (VkSurfaceKHR)global_unique_handle++;
3618     return VK_SUCCESS;
3619 }
3620 #endif /* VK_USE_PLATFORM_MACOS_MVK */
3621
3622
3623
3624
3625 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
3626     VkDevice                                    device,
3627     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo)
3628 {
3629 //Not a CREATE or DESTROY function
3630     return VK_SUCCESS;
3631 }
3632
3633 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
3634     VkDevice                                    device,
3635     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo)
3636 {
3637 //Not a CREATE or DESTROY function
3638     return VK_SUCCESS;
3639 }
3640
3641 static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
3642     VkQueue                                     queue,
3643     const VkDebugUtilsLabelEXT*                 pLabelInfo)
3644 {
3645 //Not a CREATE or DESTROY function
3646 }
3647
3648 static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
3649     VkQueue                                     queue)
3650 {
3651 //Not a CREATE or DESTROY function
3652 }
3653
3654 static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
3655     VkQueue                                     queue,
3656     const VkDebugUtilsLabelEXT*                 pLabelInfo)
3657 {
3658 //Not a CREATE or DESTROY function
3659 }
3660
3661 static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
3662     VkCommandBuffer                             commandBuffer,
3663     const VkDebugUtilsLabelEXT*                 pLabelInfo)
3664 {
3665 //Not a CREATE or DESTROY function
3666 }
3667
3668 static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
3669     VkCommandBuffer                             commandBuffer)
3670 {
3671 //Not a CREATE or DESTROY function
3672 }
3673
3674 static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
3675     VkCommandBuffer                             commandBuffer,
3676     const VkDebugUtilsLabelEXT*                 pLabelInfo)
3677 {
3678 //Not a CREATE or DESTROY function
3679 }
3680
3681 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
3682     VkInstance                                  instance,
3683     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
3684     const VkAllocationCallbacks*                pAllocator,
3685     VkDebugUtilsMessengerEXT*                   pMessenger)
3686 {
3687     unique_lock_t lock(global_lock);
3688     *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++;
3689     return VK_SUCCESS;
3690 }
3691
3692 static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
3693     VkInstance                                  instance,
3694     VkDebugUtilsMessengerEXT                    messenger,
3695     const VkAllocationCallbacks*                pAllocator)
3696 {
3697 //Destroy object
3698 }
3699
3700 static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
3701     VkInstance                                  instance,
3702     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
3703     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
3704     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
3705 {
3706 //Not a CREATE or DESTROY function
3707 }
3708
3709 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3710
3711 static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
3712     VkDevice                                    device,
3713     const struct AHardwareBuffer*               buffer,
3714     VkAndroidHardwareBufferPropertiesANDROID*   pProperties)
3715 {
3716 //Not a CREATE or DESTROY function
3717     return VK_SUCCESS;
3718 }
3719
3720 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
3721     VkDevice                                    device,
3722     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
3723     struct AHardwareBuffer**                    pBuffer)
3724 {
3725 //Not a CREATE or DESTROY function
3726     return VK_SUCCESS;
3727 }
3728 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
3729
3730
3731
3732
3733
3734
3735
3736
3737 static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
3738     VkCommandBuffer                             commandBuffer,
3739     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo)
3740 {
3741 //Not a CREATE or DESTROY function
3742 }
3743
3744 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
3745     VkPhysicalDevice                            physicalDevice,
3746     VkSampleCountFlagBits                       samples,
3747     VkMultisamplePropertiesEXT*                 pMultisampleProperties)
3748 {
3749 //Not a CREATE or DESTROY function
3750 }
3751
3752
3753
3754
3755
3756
3757
3758
3759 static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
3760     VkDevice                                    device,
3761     VkImage                                     image,
3762     VkImageDrmFormatModifierPropertiesEXT*      pProperties)
3763 {
3764 //Not a CREATE or DESTROY function
3765     return VK_SUCCESS;
3766 }
3767
3768
3769 static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
3770     VkDevice                                    device,
3771     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
3772     const VkAllocationCallbacks*                pAllocator,
3773     VkValidationCacheEXT*                       pValidationCache)
3774 {
3775     unique_lock_t lock(global_lock);
3776     *pValidationCache = (VkValidationCacheEXT)global_unique_handle++;
3777     return VK_SUCCESS;
3778 }
3779
3780 static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
3781     VkDevice                                    device,
3782     VkValidationCacheEXT                        validationCache,
3783     const VkAllocationCallbacks*                pAllocator)
3784 {
3785 //Destroy object
3786 }
3787
3788 static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
3789     VkDevice                                    device,
3790     VkValidationCacheEXT                        dstCache,
3791     uint32_t                                    srcCacheCount,
3792     const VkValidationCacheEXT*                 pSrcCaches)
3793 {
3794 //Not a CREATE or DESTROY function
3795     return VK_SUCCESS;
3796 }
3797
3798 static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
3799     VkDevice                                    device,
3800     VkValidationCacheEXT                        validationCache,
3801     size_t*                                     pDataSize,
3802     void*                                       pData)
3803 {
3804 //Not a CREATE or DESTROY function
3805     return VK_SUCCESS;
3806 }
3807
3808
3809
3810
3811 static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
3812     VkCommandBuffer                             commandBuffer,
3813     VkImageView                                 imageView,
3814     VkImageLayout                               imageLayout)
3815 {
3816 //Not a CREATE or DESTROY function
3817 }
3818
3819 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
3820     VkCommandBuffer                             commandBuffer,
3821     uint32_t                                    firstViewport,
3822     uint32_t                                    viewportCount,
3823     const VkShadingRatePaletteNV*               pShadingRatePalettes)
3824 {
3825 //Not a CREATE or DESTROY function
3826 }
3827
3828 static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
3829     VkCommandBuffer                             commandBuffer,
3830     VkCoarseSampleOrderTypeNV                   sampleOrderType,
3831     uint32_t                                    customSampleOrderCount,
3832     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders)
3833 {
3834 //Not a CREATE or DESTROY function
3835 }
3836
3837
3838 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
3839     VkDevice                                    device,
3840     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
3841     const VkAllocationCallbacks*                pAllocator,
3842     VkAccelerationStructureNV*                  pAccelerationStructure)
3843 {
3844     unique_lock_t lock(global_lock);
3845     *pAccelerationStructure = (VkAccelerationStructureNV)CreateDispObjHandle();
3846     return VK_SUCCESS;
3847 }
3848
3849 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
3850     VkDevice                                    device,
3851     VkAccelerationStructureKHR                  accelerationStructure,
3852     const VkAllocationCallbacks*                pAllocator)
3853 {
3854 //Destroy object
3855 }
3856
3857 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
3858     VkDevice                                    device,
3859     VkAccelerationStructureKHR                  accelerationStructure,
3860     const VkAllocationCallbacks*                pAllocator)
3861 {
3862 //Destroy object
3863 }
3864
3865 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
3866     VkDevice                                    device,
3867     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
3868     VkMemoryRequirements2KHR*                   pMemoryRequirements)
3869 {
3870 //Not a CREATE or DESTROY function
3871 }
3872
3873 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryKHR(
3874     VkDevice                                    device,
3875     uint32_t                                    bindInfoCount,
3876     const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos)
3877 {
3878 //Not a CREATE or DESTROY function
3879     return VK_SUCCESS;
3880 }
3881
3882 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
3883     VkDevice                                    device,
3884     uint32_t                                    bindInfoCount,
3885     const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos)
3886 {
3887 //Not a CREATE or DESTROY function
3888     return VK_SUCCESS;
3889 }
3890
3891 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
3892     VkCommandBuffer                             commandBuffer,
3893     const VkAccelerationStructureInfoNV*        pInfo,
3894     VkBuffer                                    instanceData,
3895     VkDeviceSize                                instanceOffset,
3896     VkBool32                                    update,
3897     VkAccelerationStructureKHR                  dst,
3898     VkAccelerationStructureKHR                  src,
3899     VkBuffer                                    scratch,
3900     VkDeviceSize                                scratchOffset)
3901 {
3902 //Not a CREATE or DESTROY function
3903 }
3904
3905 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
3906     VkCommandBuffer                             commandBuffer,
3907     VkAccelerationStructureKHR                  dst,
3908     VkAccelerationStructureKHR                  src,
3909     VkCopyAccelerationStructureModeKHR          mode)
3910 {
3911 //Not a CREATE or DESTROY function
3912 }
3913
3914 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
3915     VkCommandBuffer                             commandBuffer,
3916     VkBuffer                                    raygenShaderBindingTableBuffer,
3917     VkDeviceSize                                raygenShaderBindingOffset,
3918     VkBuffer                                    missShaderBindingTableBuffer,
3919     VkDeviceSize                                missShaderBindingOffset,
3920     VkDeviceSize                                missShaderBindingStride,
3921     VkBuffer                                    hitShaderBindingTableBuffer,
3922     VkDeviceSize                                hitShaderBindingOffset,
3923     VkDeviceSize                                hitShaderBindingStride,
3924     VkBuffer                                    callableShaderBindingTableBuffer,
3925     VkDeviceSize                                callableShaderBindingOffset,
3926     VkDeviceSize                                callableShaderBindingStride,
3927     uint32_t                                    width,
3928     uint32_t                                    height,
3929     uint32_t                                    depth)
3930 {
3931 //Not a CREATE or DESTROY function
3932 }
3933
3934 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
3935     VkDevice                                    device,
3936     VkPipelineCache                             pipelineCache,
3937     uint32_t                                    createInfoCount,
3938     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
3939     const VkAllocationCallbacks*                pAllocator,
3940     VkPipeline*                                 pPipelines)
3941 {
3942     unique_lock_t lock(global_lock);
3943     for (uint32_t i = 0; i < createInfoCount; ++i) {
3944         pPipelines[i] = (VkPipeline)global_unique_handle++;
3945     }
3946     return VK_SUCCESS;
3947 }
3948
3949 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
3950     VkDevice                                    device,
3951     VkPipeline                                  pipeline,
3952     uint32_t                                    firstGroup,
3953     uint32_t                                    groupCount,
3954     size_t                                      dataSize,
3955     void*                                       pData)
3956 {
3957 //Not a CREATE or DESTROY function
3958     return VK_SUCCESS;
3959 }
3960
3961 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
3962     VkDevice                                    device,
3963     VkPipeline                                  pipeline,
3964     uint32_t                                    firstGroup,
3965     uint32_t                                    groupCount,
3966     size_t                                      dataSize,
3967     void*                                       pData)
3968 {
3969 //Not a CREATE or DESTROY function
3970     return VK_SUCCESS;
3971 }
3972
3973 static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
3974     VkDevice                                    device,
3975     VkAccelerationStructureKHR                  accelerationStructure,
3976     size_t                                      dataSize,
3977     void*                                       pData)
3978 {
3979 //Not a CREATE or DESTROY function
3980     return VK_SUCCESS;
3981 }
3982
3983 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
3984     VkCommandBuffer                             commandBuffer,
3985     uint32_t                                    accelerationStructureCount,
3986     const VkAccelerationStructureKHR*           pAccelerationStructures,
3987     VkQueryType                                 queryType,
3988     VkQueryPool                                 queryPool,
3989     uint32_t                                    firstQuery)
3990 {
3991 //Not a CREATE or DESTROY function
3992 }
3993
3994 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
3995     VkCommandBuffer                             commandBuffer,
3996     uint32_t                                    accelerationStructureCount,
3997     const VkAccelerationStructureKHR*           pAccelerationStructures,
3998     VkQueryType                                 queryType,
3999     VkQueryPool                                 queryPool,
4000     uint32_t                                    firstQuery)
4001 {
4002 //Not a CREATE or DESTROY function
4003 }
4004
4005 static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
4006     VkDevice                                    device,
4007     VkPipeline                                  pipeline,
4008     uint32_t                                    shader)
4009 {
4010 //Not a CREATE or DESTROY function
4011     return VK_SUCCESS;
4012 }
4013
4014
4015
4016
4017
4018 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
4019     VkDevice                                    device,
4020     VkExternalMemoryHandleTypeFlagBits          handleType,
4021     const void*                                 pHostPointer,
4022     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties)
4023 {
4024 //Not a CREATE or DESTROY function
4025     return VK_SUCCESS;
4026 }
4027
4028
4029 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
4030     VkCommandBuffer                             commandBuffer,
4031     VkPipelineStageFlagBits                     pipelineStage,
4032     VkBuffer                                    dstBuffer,
4033     VkDeviceSize                                dstOffset,
4034     uint32_t                                    marker)
4035 {
4036 //Not a CREATE or DESTROY function
4037 }
4038
4039
4040
4041 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
4042     VkPhysicalDevice                            physicalDevice,
4043     uint32_t*                                   pTimeDomainCount,
4044     VkTimeDomainEXT*                            pTimeDomains)
4045 {
4046 //Not a CREATE or DESTROY function
4047     return VK_SUCCESS;
4048 }
4049
4050 static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
4051     VkDevice                                    device,
4052     uint32_t                                    timestampCount,
4053     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
4054     uint64_t*                                   pTimestamps,
4055     uint64_t*                                   pMaxDeviation)
4056 {
4057 //Not a CREATE or DESTROY function
4058     return VK_SUCCESS;
4059 }
4060
4061
4062
4063
4064 #ifdef VK_USE_PLATFORM_GGP
4065 #endif /* VK_USE_PLATFORM_GGP */
4066
4067
4068
4069
4070
4071 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
4072     VkCommandBuffer                             commandBuffer,
4073     uint32_t                                    taskCount,
4074     uint32_t                                    firstTask)
4075 {
4076 //Not a CREATE or DESTROY function
4077 }
4078
4079 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
4080     VkCommandBuffer                             commandBuffer,
4081     VkBuffer                                    buffer,
4082     VkDeviceSize                                offset,
4083     uint32_t                                    drawCount,
4084     uint32_t                                    stride)
4085 {
4086 //Not a CREATE or DESTROY function
4087 }
4088
4089 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
4090     VkCommandBuffer                             commandBuffer,
4091     VkBuffer                                    buffer,
4092     VkDeviceSize                                offset,
4093     VkBuffer                                    countBuffer,
4094     VkDeviceSize                                countBufferOffset,
4095     uint32_t                                    maxDrawCount,
4096     uint32_t                                    stride)
4097 {
4098 //Not a CREATE or DESTROY function
4099 }
4100
4101
4102
4103
4104 static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
4105     VkCommandBuffer                             commandBuffer,
4106     uint32_t                                    firstExclusiveScissor,
4107     uint32_t                                    exclusiveScissorCount,
4108     const VkRect2D*                             pExclusiveScissors)
4109 {
4110 //Not a CREATE or DESTROY function
4111 }
4112
4113
4114 static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
4115     VkCommandBuffer                             commandBuffer,
4116     const void*                                 pCheckpointMarker)
4117 {
4118 //Not a CREATE or DESTROY function
4119 }
4120
4121 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
4122     VkQueue                                     queue,
4123     uint32_t*                                   pCheckpointDataCount,
4124     VkCheckpointDataNV*                         pCheckpointData)
4125 {
4126 //Not a CREATE or DESTROY function
4127 }
4128
4129
4130
4131 static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
4132     VkDevice                                    device,
4133     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo)
4134 {
4135 //Not a CREATE or DESTROY function
4136     return VK_SUCCESS;
4137 }
4138
4139 static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
4140     VkDevice                                    device)
4141 {
4142 //Not a CREATE or DESTROY function
4143 }
4144
4145 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
4146     VkCommandBuffer                             commandBuffer,
4147     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo)
4148 {
4149 //Not a CREATE or DESTROY function
4150     return VK_SUCCESS;
4151 }
4152
4153 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
4154     VkCommandBuffer                             commandBuffer,
4155     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo)
4156 {
4157 //Not a CREATE or DESTROY function
4158     return VK_SUCCESS;
4159 }
4160
4161 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
4162     VkCommandBuffer                             commandBuffer,
4163     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo)
4164 {
4165 //Not a CREATE or DESTROY function
4166     return VK_SUCCESS;
4167 }
4168
4169 static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
4170     VkDevice                                    device,
4171     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
4172     VkPerformanceConfigurationINTEL*            pConfiguration)
4173 {
4174 //Not a CREATE or DESTROY function
4175     return VK_SUCCESS;
4176 }
4177
4178 static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
4179     VkDevice                                    device,
4180     VkPerformanceConfigurationINTEL             configuration)
4181 {
4182 //Not a CREATE or DESTROY function
4183     return VK_SUCCESS;
4184 }
4185
4186 static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
4187     VkQueue                                     queue,
4188     VkPerformanceConfigurationINTEL             configuration)
4189 {
4190 //Not a CREATE or DESTROY function
4191     return VK_SUCCESS;
4192 }
4193
4194 static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
4195     VkDevice                                    device,
4196     VkPerformanceParameterTypeINTEL             parameter,
4197     VkPerformanceValueINTEL*                    pValue)
4198 {
4199 //Not a CREATE or DESTROY function
4200     return VK_SUCCESS;
4201 }
4202
4203
4204
4205 static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
4206     VkDevice                                    device,
4207     VkSwapchainKHR                              swapChain,
4208     VkBool32                                    localDimmingEnable)
4209 {
4210 //Not a CREATE or DESTROY function
4211 }
4212
4213 #ifdef VK_USE_PLATFORM_FUCHSIA
4214
4215 static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
4216     VkInstance                                  instance,
4217     const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
4218     const VkAllocationCallbacks*                pAllocator,
4219     VkSurfaceKHR*                               pSurface)
4220 {
4221     unique_lock_t lock(global_lock);
4222     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4223     return VK_SUCCESS;
4224 }
4225 #endif /* VK_USE_PLATFORM_FUCHSIA */
4226
4227 #ifdef VK_USE_PLATFORM_METAL_EXT
4228
4229 static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
4230     VkInstance                                  instance,
4231     const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
4232     const VkAllocationCallbacks*                pAllocator,
4233     VkSurfaceKHR*                               pSurface)
4234 {
4235     unique_lock_t lock(global_lock);
4236     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4237     return VK_SUCCESS;
4238 }
4239 #endif /* VK_USE_PLATFORM_METAL_EXT */
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251
4252 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
4253     VkDevice                                    device,
4254     const VkBufferDeviceAddressInfo*            pInfo)
4255 {
4256 //Not a CREATE or DESTROY function
4257     return VK_SUCCESS;
4258 }
4259
4260
4261 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
4262     VkPhysicalDevice                            physicalDevice,
4263     uint32_t*                                   pToolCount,
4264     VkPhysicalDeviceToolPropertiesEXT*          pToolProperties)
4265 {
4266 //Not a CREATE or DESTROY function
4267     return VK_SUCCESS;
4268 }
4269
4270
4271
4272
4273 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
4274     VkPhysicalDevice                            physicalDevice,
4275     uint32_t*                                   pPropertyCount,
4276     VkCooperativeMatrixPropertiesNV*            pProperties)
4277 {
4278 //Not a CREATE or DESTROY function
4279     return VK_SUCCESS;
4280 }
4281
4282
4283 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
4284     VkPhysicalDevice                            physicalDevice,
4285     uint32_t*                                   pCombinationCount,
4286     VkFramebufferMixedSamplesCombinationNV*     pCombinations)
4287 {
4288 //Not a CREATE or DESTROY function
4289     return VK_SUCCESS;
4290 }
4291
4292
4293
4294 #ifdef VK_USE_PLATFORM_WIN32_KHR
4295
4296 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
4297     VkPhysicalDevice                            physicalDevice,
4298     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
4299     uint32_t*                                   pPresentModeCount,
4300     VkPresentModeKHR*                           pPresentModes)
4301 {
4302 //Not a CREATE or DESTROY function
4303     return VK_SUCCESS;
4304 }
4305
4306 static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
4307     VkDevice                                    device,
4308     VkSwapchainKHR                              swapchain)
4309 {
4310 //Not a CREATE or DESTROY function
4311     return VK_SUCCESS;
4312 }
4313
4314 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
4315     VkDevice                                    device,
4316     VkSwapchainKHR                              swapchain)
4317 {
4318 //Not a CREATE or DESTROY function
4319     return VK_SUCCESS;
4320 }
4321
4322 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
4323     VkDevice                                    device,
4324     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
4325     VkDeviceGroupPresentModeFlagsKHR*           pModes)
4326 {
4327 //Not a CREATE or DESTROY function
4328     return VK_SUCCESS;
4329 }
4330 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4331
4332
4333 static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
4334     VkInstance                                  instance,
4335     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
4336     const VkAllocationCallbacks*                pAllocator,
4337     VkSurfaceKHR*                               pSurface)
4338 {
4339     unique_lock_t lock(global_lock);
4340     *pSurface = (VkSurfaceKHR)global_unique_handle++;
4341     return VK_SUCCESS;
4342 }
4343
4344
4345 static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
4346     VkCommandBuffer                             commandBuffer,
4347     uint32_t                                    lineStippleFactor,
4348     uint16_t                                    lineStipplePattern)
4349 {
4350 //Not a CREATE or DESTROY function
4351 }
4352
4353
4354 static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
4355     VkDevice                                    device,
4356     VkQueryPool                                 queryPool,
4357     uint32_t                                    firstQuery,
4358     uint32_t                                    queryCount)
4359 {
4360 //Not a CREATE or DESTROY function
4361 }
4362
4363
4364
4365
4366 static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
4367     VkDevice                                    device,
4368     const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
4369     VkMemoryRequirements2*                      pMemoryRequirements)
4370 {
4371 //Not a CREATE or DESTROY function
4372 }
4373
4374 static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
4375     VkCommandBuffer                             commandBuffer,
4376     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo)
4377 {
4378 //Not a CREATE or DESTROY function
4379 }
4380
4381 static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
4382     VkCommandBuffer                             commandBuffer,
4383     VkBool32                                    isPreprocessed,
4384     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo)
4385 {
4386 //Not a CREATE or DESTROY function
4387 }
4388
4389 static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
4390     VkCommandBuffer                             commandBuffer,
4391     VkPipelineBindPoint                         pipelineBindPoint,
4392     VkPipeline                                  pipeline,
4393     uint32_t                                    groupIndex)
4394 {
4395 //Not a CREATE or DESTROY function
4396 }
4397
4398 static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
4399     VkDevice                                    device,
4400     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
4401     const VkAllocationCallbacks*                pAllocator,
4402     VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout)
4403 {
4404     unique_lock_t lock(global_lock);
4405     *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++;
4406     return VK_SUCCESS;
4407 }
4408
4409 static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
4410     VkDevice                                    device,
4411     VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
4412     const VkAllocationCallbacks*                pAllocator)
4413 {
4414 //Destroy object
4415 }
4416
4417
4418
4419
4420
4421
4422 #ifdef VK_ENABLE_BETA_EXTENSIONS
4423
4424 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
4425     VkDevice                                    device,
4426     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
4427     const VkAllocationCallbacks*                pAllocator,
4428     VkAccelerationStructureKHR*                 pAccelerationStructure)
4429 {
4430     unique_lock_t lock(global_lock);
4431     *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++;
4432     return VK_SUCCESS;
4433 }
4434
4435 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsKHR(
4436     VkDevice                                    device,
4437     const VkAccelerationStructureMemoryRequirementsInfoKHR* pInfo,
4438     VkMemoryRequirements2*                      pMemoryRequirements)
4439 {
4440 //Not a CREATE or DESTROY function
4441 }
4442
4443 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureKHR(
4444     VkCommandBuffer                             commandBuffer,
4445     uint32_t                                    infoCount,
4446     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
4447     const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos)
4448 {
4449 //Not a CREATE or DESTROY function
4450 }
4451
4452 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureIndirectKHR(
4453     VkCommandBuffer                             commandBuffer,
4454     const VkAccelerationStructureBuildGeometryInfoKHR* pInfo,
4455     VkBuffer                                    indirectBuffer,
4456     VkDeviceSize                                indirectOffset,
4457     uint32_t                                    indirectStride)
4458 {
4459 //Not a CREATE or DESTROY function
4460 }
4461
4462 static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructureKHR(
4463     VkDevice                                    device,
4464     uint32_t                                    infoCount,
4465     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
4466     const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos)
4467 {
4468 //Not a CREATE or DESTROY function
4469     return VK_SUCCESS;
4470 }
4471
4472 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(
4473     VkDevice                                    device,
4474     const VkCopyAccelerationStructureInfoKHR*   pInfo)
4475 {
4476 //Not a CREATE or DESTROY function
4477     return VK_SUCCESS;
4478 }
4479
4480 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
4481     VkDevice                                    device,
4482     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
4483 {
4484 //Not a CREATE or DESTROY function
4485     return VK_SUCCESS;
4486 }
4487
4488 static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
4489     VkDevice                                    device,
4490     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
4491 {
4492 //Not a CREATE or DESTROY function
4493     return VK_SUCCESS;
4494 }
4495
4496 static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
4497     VkDevice                                    device,
4498     uint32_t                                    accelerationStructureCount,
4499     const VkAccelerationStructureKHR*           pAccelerationStructures,
4500     VkQueryType                                 queryType,
4501     size_t                                      dataSize,
4502     void*                                       pData,
4503     size_t                                      stride)
4504 {
4505 //Not a CREATE or DESTROY function
4506     return VK_SUCCESS;
4507 }
4508
4509 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
4510     VkCommandBuffer                             commandBuffer,
4511     const VkCopyAccelerationStructureInfoKHR*   pInfo)
4512 {
4513 //Not a CREATE or DESTROY function
4514 }
4515
4516 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
4517     VkCommandBuffer                             commandBuffer,
4518     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
4519 {
4520 //Not a CREATE or DESTROY function
4521 }
4522
4523 static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
4524     VkCommandBuffer                             commandBuffer,
4525     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
4526 {
4527 //Not a CREATE or DESTROY function
4528 }
4529
4530 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
4531     VkCommandBuffer                             commandBuffer,
4532     const VkStridedBufferRegionKHR*             pRaygenShaderBindingTable,
4533     const VkStridedBufferRegionKHR*             pMissShaderBindingTable,
4534     const VkStridedBufferRegionKHR*             pHitShaderBindingTable,
4535     const VkStridedBufferRegionKHR*             pCallableShaderBindingTable,
4536     uint32_t                                    width,
4537     uint32_t                                    height,
4538     uint32_t                                    depth)
4539 {
4540 //Not a CREATE or DESTROY function
4541 }
4542
4543 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
4544     VkDevice                                    device,
4545     VkPipelineCache                             pipelineCache,
4546     uint32_t                                    createInfoCount,
4547     const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
4548     const VkAllocationCallbacks*                pAllocator,
4549     VkPipeline*                                 pPipelines)
4550 {
4551     unique_lock_t lock(global_lock);
4552     for (uint32_t i = 0; i < createInfoCount; ++i) {
4553         pPipelines[i] = (VkPipeline)global_unique_handle++;
4554     }
4555     return VK_SUCCESS;
4556 }
4557
4558 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
4559     VkDevice                                    device,
4560     const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
4561 {
4562 //Not a CREATE or DESTROY function
4563     return VK_SUCCESS;
4564 }
4565
4566 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
4567     VkDevice                                    device,
4568     VkPipeline                                  pipeline,
4569     uint32_t                                    firstGroup,
4570     uint32_t                                    groupCount,
4571     size_t                                      dataSize,
4572     void*                                       pData)
4573 {
4574 //Not a CREATE or DESTROY function
4575     return VK_SUCCESS;
4576 }
4577
4578 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
4579     VkCommandBuffer                             commandBuffer,
4580     const VkStridedBufferRegionKHR*             pRaygenShaderBindingTable,
4581     const VkStridedBufferRegionKHR*             pMissShaderBindingTable,
4582     const VkStridedBufferRegionKHR*             pHitShaderBindingTable,
4583     const VkStridedBufferRegionKHR*             pCallableShaderBindingTable,
4584     VkBuffer                                    buffer,
4585     VkDeviceSize                                offset)
4586 {
4587 //Not a CREATE or DESTROY function
4588 }
4589
4590 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
4591     VkDevice                                    device,
4592     const VkAccelerationStructureVersionKHR*    version)
4593 {
4594 //Not a CREATE or DESTROY function
4595     return VK_SUCCESS;
4596 }
4597 #endif /* VK_ENABLE_BETA_EXTENSIONS */
4598
4599
4600
4601 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
4602     // TODO: This function should only care about physical device functions and return nullptr for other functions
4603     const auto &item = name_to_funcptr_map.find(funcName);
4604     if (item != name_to_funcptr_map.end()) {
4605         return reinterpret_cast<PFN_vkVoidFunction>(item->second);
4606     }
4607     // Mock should intercept all functions so if we get here just return null
4608     return nullptr;
4609 }
4610
4611 } // namespace vkmock
4612
4613 #if defined(__GNUC__) && __GNUC__ >= 4
4614 #define EXPORT __attribute__((visibility("default")))
4615 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
4616 #define EXPORT __attribute__((visibility("default")))
4617 #else
4618 #define EXPORT
4619 #endif
4620
4621 extern "C" {
4622
4623 EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) {
4624     if (!vkmock::negotiate_loader_icd_interface_called) {
4625         vkmock::loader_interface_version = 1;
4626     }
4627     return vkmock::GetInstanceProcAddr(instance, pName);
4628 }
4629
4630 EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName) {
4631     return vkmock::GetPhysicalDeviceProcAddr(instance, pName);
4632 }
4633
4634 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
4635     vkmock::negotiate_loader_icd_interface_called = true;
4636     vkmock::loader_interface_version = *pSupportedVersion;
4637     if (*pSupportedVersion > vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION) {
4638         *pSupportedVersion = vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION;
4639     }
4640     return VK_SUCCESS;
4641 }
4642
4643
4644 EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
4645     VkInstance                                  instance,
4646     VkSurfaceKHR                                surface,
4647     const VkAllocationCallbacks*                pAllocator)
4648 {
4649     vkmock::DestroySurfaceKHR(instance, surface, pAllocator);
4650 }
4651
4652 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
4653     VkPhysicalDevice                            physicalDevice,
4654     uint32_t                                    queueFamilyIndex,
4655     VkSurfaceKHR                                surface,
4656     VkBool32*                                   pSupported)
4657 {
4658     return vkmock::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
4659 }
4660
4661 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
4662     VkPhysicalDevice                            physicalDevice,
4663     VkSurfaceKHR                                surface,
4664     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities)
4665 {
4666     return vkmock::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
4667 }
4668
4669 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
4670     VkPhysicalDevice                            physicalDevice,
4671     VkSurfaceKHR                                surface,
4672     uint32_t*                                   pSurfaceFormatCount,
4673     VkSurfaceFormatKHR*                         pSurfaceFormats)
4674 {
4675     return vkmock::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
4676 }
4677
4678 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
4679     VkPhysicalDevice                            physicalDevice,
4680     VkSurfaceKHR                                surface,
4681     uint32_t*                                   pPresentModeCount,
4682     VkPresentModeKHR*                           pPresentModes)
4683 {
4684     return vkmock::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
4685 }
4686
4687 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
4688     VkInstance                                  instance,
4689     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
4690     const VkAllocationCallbacks*                pAllocator,
4691     VkSurfaceKHR*                               pSurface)
4692 {
4693     return vkmock::CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4694 }
4695
4696 #ifdef VK_USE_PLATFORM_XLIB_KHR
4697
4698 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
4699     VkInstance                                  instance,
4700     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
4701     const VkAllocationCallbacks*                pAllocator,
4702     VkSurfaceKHR*                               pSurface)
4703 {
4704     return vkmock::CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4705 }
4706 #endif /* VK_USE_PLATFORM_XLIB_KHR */
4707
4708 #ifdef VK_USE_PLATFORM_XCB_KHR
4709
4710 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
4711     VkInstance                                  instance,
4712     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
4713     const VkAllocationCallbacks*                pAllocator,
4714     VkSurfaceKHR*                               pSurface)
4715 {
4716     return vkmock::CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4717 }
4718 #endif /* VK_USE_PLATFORM_XCB_KHR */
4719
4720 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
4721
4722 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
4723     VkInstance                                  instance,
4724     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
4725     const VkAllocationCallbacks*                pAllocator,
4726     VkSurfaceKHR*                               pSurface)
4727 {
4728     return vkmock::CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4729 }
4730 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
4731
4732 #ifdef VK_USE_PLATFORM_ANDROID_KHR
4733
4734 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
4735     VkInstance                                  instance,
4736     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
4737     const VkAllocationCallbacks*                pAllocator,
4738     VkSurfaceKHR*                               pSurface)
4739 {
4740     return vkmock::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4741 }
4742 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
4743
4744 #ifdef VK_USE_PLATFORM_WIN32_KHR
4745
4746 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
4747     VkInstance                                  instance,
4748     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
4749     const VkAllocationCallbacks*                pAllocator,
4750     VkSurfaceKHR*                               pSurface)
4751 {
4752     return vkmock::CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
4753 }
4754 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4755
4756 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
4757     VkDevice                                    device,
4758     VkSurfaceKHR                                surface,
4759     VkDeviceGroupPresentModeFlagsKHR*           pModes)
4760 {
4761     return vkmock::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
4762 }
4763
4764 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
4765     VkPhysicalDevice                            physicalDevice,
4766     VkSurfaceKHR                                surface,
4767     uint32_t*                                   pRectCount,
4768     VkRect2D*                                   pRects)
4769 {
4770     return vkmock::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
4771 }
4772
4773 #ifdef VK_USE_PLATFORM_VI_NN
4774
4775 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
4776     VkInstance                                  instance,
4777     const VkViSurfaceCreateInfoNN*              pCreateInfo,
4778     const VkAllocationCallbacks*                pAllocator,
4779     VkSurfaceKHR*                               pSurface)
4780 {
4781     return vkmock::CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
4782 }
4783 #endif /* VK_USE_PLATFORM_VI_NN */
4784
4785 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
4786     VkPhysicalDevice                            physicalDevice,
4787     VkSurfaceKHR                                surface,
4788     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities)
4789 {
4790     return vkmock::GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
4791 }
4792
4793 #ifdef VK_USE_PLATFORM_IOS_MVK
4794
4795 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
4796     VkInstance                                  instance,
4797     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
4798     const VkAllocationCallbacks*                pAllocator,
4799     VkSurfaceKHR*                               pSurface)
4800 {
4801     return vkmock::CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
4802 }
4803 #endif /* VK_USE_PLATFORM_IOS_MVK */
4804
4805 #ifdef VK_USE_PLATFORM_MACOS_MVK
4806
4807 EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
4808     VkInstance                                  instance,
4809     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
4810     const VkAllocationCallbacks*                pAllocator,
4811     VkSurfaceKHR*                               pSurface)
4812 {
4813     return vkmock::CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
4814 }
4815 #endif /* VK_USE_PLATFORM_MACOS_MVK */
4816
4817 } // end extern "C"
4818
4819