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