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