icd/generated/mock_icd.cpp

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