Lines Matching refs:device

114 // Get a device level or global level entry point address.
115 // @param device
118 // If device is valid, returns a device relative entry point for device level
120 // Device relative means call down the device chain.
121 LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName) {
133 // Although CreateDevice is on device chain it's dispatchable object isn't
142 struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &index);
154 const VkLayerDispatchTable *disp_table = loader_get_dispatch(device);
162 return disp_table->GetDeviceProcAddr(device, pName);
886 "vkEnumeratePhysicalDevices: Received NULL pointer for physical device count return value. "
892 // Call down the chain to get the physical device info
1009 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
1012 if (device == VK_NULL_HANDLE) {
1015 disp = loader_get_dispatch(device);
1018 "vkDestroyDevice: Invalid device [VUID-vkDestroyDevice-device-parameter]");
1024 loader_layer_destroy_device(device, pAllocator, disp->DestroyDevice);
1063 // Don't dispatch this call down the instance chain, want all device layers
1064 // enumerated and instance chain may not contain all device layers
1101 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
1103 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1106 "vkGetDeviceQueue: Invalid device [VUID-vkGetDeviceQueue-device-parameter]");
1110 disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
1139 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
1140 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1143 "vkDeviceWaitIdle: Invalid device [VUID-vkDeviceWaitIdle-device-parameter]");
1147 return disp->DeviceWaitIdle(device);
1150 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
1152 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1155 "vkAllocateMemory: Invalid device [VUID-vkAllocateMemory-device-parameter]");
1159 return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
1162 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem,
1164 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1167 "vkFreeMemory: Invalid device [VUID-vkFreeMemory-device-parameter]");
1171 disp->FreeMemory(device, mem, pAllocator);
1174 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
1176 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1179 "vkMapMemory: Invalid device [VUID-vkMapMemory-device-parameter]");
1183 return disp->MapMemory(device, mem, offset, size, flags, ppData);
1186 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
1187 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1190 "vkUnmapMemory: Invalid device [VUID-vkUnmapMemory-device-parameter]");
1194 disp->UnmapMemory(device, mem);
1197 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
1199 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1202 "vkFlushMappedMemoryRanges: Invalid device [VUID-vkFlushMappedMemoryRanges-device-parameter]");
1206 return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1209 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
1211 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1214 "vkInvalidateMappedMemoryRanges: Invalid device [VUID-vkInvalidateMappedMemoryRanges-device-parameter]");
1218 return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1221 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
1223 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1226 "vkGetDeviceMemoryCommitment: Invalid device [VUID-vkGetDeviceMemoryCommitment-device-parameter]");
1230 disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
1233 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
1235 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1238 "vkBindBufferMemory: Invalid device [VUID-vkBindBufferMemory-device-parameter]");
1242 return disp->BindBufferMemory(device, buffer, mem, offset);
1245 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
1247 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1250 "vkBindImageMemory: Invalid device [VUID-vkBindImageMemory-device-parameter]");
1254 return disp->BindImageMemory(device, image, mem, offset);
1257 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
1259 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1262 "vkGetBufferMemoryRequirements: Invalid device [VUID-vkGetBufferMemoryRequirements-device-parameter]");
1266 disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
1269 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image,
1271 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1274 "vkGetImageMemoryRequirements: Invalid device [VUID-vkGetImageMemoryRequirements-device-parameter]");
1278 disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
1282 vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
1284 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1287 "vkGetImageSparseMemoryRequirements: Invalid device [VUID-vkGetImageSparseMemoryRequirements-device-parameter]");
1291 disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1323 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
1325 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1328 "vkCreateFence: Invalid device [VUID-vkCreateFence-device-parameter]");
1332 return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
1335 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
1336 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1339 "vkDestroyFence: Invalid device [VUID-vkDestroyFence-device-parameter]");
1343 disp->DestroyFence(device, fence, pAllocator);
1346 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
1347 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1350 "vkResetFences: Invalid device [VUID-vkResetFences-device-parameter]");
1354 return disp->ResetFences(device, fenceCount, pFences);
1357 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
1358 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1361 "vkGetFenceStatus: Invalid device [VUID-vkGetFenceStatus-device-parameter]");
1365 return disp->GetFenceStatus(device, fence);
1368 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
1370 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1373 "vkWaitForFences: Invalid device [VUID-vkWaitForFences-device-parameter]");
1377 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
1380 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
1382 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1385 "vkCreateSemaphore: Invalid device [VUID-vkCreateSemaphore-device-parameter]");
1389 return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
1392 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
1394 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1397 "vkDestroySemaphore: Invalid device [VUID-vkDestroySemaphore-device-parameter]");
1401 disp->DestroySemaphore(device, semaphore, pAllocator);
1404 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
1406 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1409 "vkCreateEvent: Invalid device [VUID-vkCreateEvent-device-parameter]");
1413 return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
1416 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
1417 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1420 "vkDestroyEvent: Invalid device [VUID-vkDestroyEvent-device-parameter]");
1424 disp->DestroyEvent(device, event, pAllocator);
1427 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
1428 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1431 "vkGetEventStatus: Invalid device [VUID-vkGetEventStatus-device-parameter]");
1435 return disp->GetEventStatus(device, event);
1438 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
1439 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1442 "vkSetEvent: Invalid device [VUID-vkSetEvent-device-parameter]");
1446 return disp->SetEvent(device, event);
1449 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
1450 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1453 "vkResetEvent: Invalid device [VUID-vkResetEvent-device-parameter]");
1457 return disp->ResetEvent(device, event);
1460 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
1462 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1465 "vkCreateQueryPool: Invalid device [VUID-vkCreateQueryPool-device-parameter]");
1469 return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
1472 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
1474 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1477 "vkDestroyQueryPool: Invalid device [VUID-vkDestroyQueryPool-device-parameter]");
1481 disp->DestroyQueryPool(device, queryPool, pAllocator);
1484 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
1487 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1490 "vkGetQueryPoolResults: Invalid device [VUID-vkGetQueryPoolResults-device-parameter]");
1494 return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
1497 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
1499 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1502 "vkCreateBuffer: Invalid device [VUID-vkCreateBuffer-device-parameter]");
1506 return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
1509 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer,
1511 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1514 "vkDestroyBuffer: Invalid device [VUID-vkDestroyBuffer-device-parameter]");
1518 disp->DestroyBuffer(device, buffer, pAllocator);
1521 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
1523 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1526 "vkCreateBufferView: Invalid device [VUID-vkCreateBufferView-device-parameter]");
1530 return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
1533 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
1535 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1538 "vkDestroyBufferView: Invalid device [VUID-vkDestroyBufferView-device-parameter]");
1542 disp->DestroyBufferView(device, bufferView, pAllocator);
1545 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1547 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1550 "vkCreateImage: Invalid device [VUID-vkCreateImage-device-parameter]");
1554 return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
1557 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
1558 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1561 "vkDestroyImage: Invalid device [VUID-vkDestroyImage-device-parameter]");
1565 disp->DestroyImage(device, image, pAllocator);
1568 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image,
1571 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1574 "vkGetImageSubresourceLayout: Invalid device [VUID-vkGetImageSubresourceLayout-device-parameter]");
1578 disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
1581 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
1583 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1586 "vkCreateImageView: Invalid device [VUID-vkCreateImageView-device-parameter]");
1590 return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
1593 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView,
1595 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1598 "vkDestroyImageView: Invalid device [VUID-vkDestroyImageView-device-parameter]");
1602 disp->DestroyImageView(device, imageView, pAllocator);
1605 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
1608 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1611 "vkCreateShaderModule: Invalid device [VUID-vkCreateShaderModule-device-parameter]");
1615 return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
1618 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
1620 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1623 "vkDestroyShaderModule: Invalid device [VUID-vkDestroyShaderModule-device-parameter]");
1627 disp->DestroyShaderModule(device, shaderModule, pAllocator);
1630 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
1633 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1636 "vkCreatePipelineCache: Invalid device [VUID-vkCreatePipelineCache-device-parameter]");
1640 return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
1643 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
1645 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1648 "vkDestroyPipelineCache: Invalid device [VUID-vkDestroyPipelineCache-device-parameter]");
1652 disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
1655 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
1657 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1660 "vkGetPipelineCacheData: Invalid device [VUID-vkGetPipelineCacheData-device-parameter]");
1664 return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
1667 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
1669 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1672 "vkMergePipelineCaches: Invalid device [VUID-vkMergePipelineCaches-device-parameter]");
1676 return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
1679 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
1684 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1687 "vkCreateGraphicsPipelines: Invalid device [VUID-vkCreateGraphicsPipelines-device-parameter]");
1691 return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1694 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
1699 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1702 "vkCreateComputePipelines: Invalid device [VUID-vkCreateComputePipelines-device-parameter]");
1706 return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1709 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
1711 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1714 "vkDestroyPipeline: Invalid device [VUID-vkDestroyPipeline-device-parameter]");
1718 disp->DestroyPipeline(device, pipeline, pAllocator);
1721 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
1724 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1727 "vkCreatePipelineLayout: Invalid device [VUID-vkCreatePipelineLayout-device-parameter]");
1731 return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
1734 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
1736 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1739 "vkDestroyPipelineLayout: Invalid device [VUID-vkDestroyPipelineLayout-device-parameter]");
1743 disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
1746 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
1748 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1751 "vkCreateSampler: Invalid device [VUID-vkCreateSampler-device-parameter]");
1755 return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
1758 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler,
1760 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1763 "vkDestroySampler: Invalid device [VUID-vkDestroySampler-device-parameter]");
1767 disp->DestroySampler(device, sampler, pAllocator);
1770 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device,
1774 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1777 "vkCreateDescriptorSetLayout: Invalid device [VUID-vkCreateDescriptorSetLayout-device-parameter]");
1781 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
1784 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
1786 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1789 "vkDestroyDescriptorSetLayout: Invalid device [VUID-vkDestroyDescriptorSetLayout-device-parameter]");
1793 disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
1796 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
1799 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1802 "vkCreateDescriptorPool: Invalid device [VUID-vkCreateDescriptorPool-device-parameter]");
1806 return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
1809 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1811 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1814 "vkDestroyDescriptorPool: Invalid device [VUID-vkDestroyDescriptorPool-device-parameter]");
1818 disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
1821 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1823 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1826 "vkResetDescriptorPool: Invalid device [VUID-vkResetDescriptorPool-device-parameter]");
1830 return disp->ResetDescriptorPool(device, descriptorPool, flags);
1833 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device,
1836 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1839 "vkAllocateDescriptorSets: Invalid device [VUID-vkAllocateDescriptorSets-device-parameter]");
1843 return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
1846 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
1849 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1852 "vkFreeDescriptorSets: Invalid device [VUID-vkFreeDescriptorSets-device-parameter]");
1856 return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
1859 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
1863 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1866 "vkUpdateDescriptorSets: Invalid device [VUID-vkUpdateDescriptorSets-device-parameter]");
1870 disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1873 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
1876 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1879 "vkCreateFramebuffer: Invalid device [VUID-vkCreateFramebuffer-device-parameter]");
1883 return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
1886 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
1888 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1891 "vkDestroyFramebuffer: Invalid device [VUID-vkDestroyFramebuffer-device-parameter]");
1895 disp->DestroyFramebuffer(device, framebuffer, pAllocator);
1898 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
1901 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1904 "vkCreateRenderPass: Invalid device [VUID-vkCreateRenderPass-device-parameter]");
1908 return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1911 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
1913 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1916 "vkDestroyRenderPass: Invalid device [VUID-vkDestroyRenderPass-device-parameter]");
1920 disp->DestroyRenderPass(device, renderPass, pAllocator);
1923 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
1925 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1928 "vkGetRenderAreaGranularity: Invalid device [VUID-vkGetRenderAreaGranularity-device-parameter]");
1932 disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
1935 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
1938 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1941 "vkCreateCommandPool: Invalid device [VUID-vkCreateCommandPool-device-parameter]");
1945 return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
1948 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
1950 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1953 "vkDestroyCommandPool: Invalid device [VUID-vkDestroyCommandPool-device-parameter]");
1957 disp->DestroyCommandPool(device, commandPool, pAllocator);
1960 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
1962 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1965 "vkResetCommandPool: Invalid device [VUID-vkResetCommandPool-device-parameter]");
1969 return disp->ResetCommandPool(device, commandPool, flags);
1972 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device,
1976 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
1979 "vkAllocateCommandBuffers: Invalid device [VUID-vkAllocateCommandBuffers-device-parameter]");
1983 res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
1995 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
1997 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2000 "vkFreeCommandBuffers: Invalid device [VUID-vkFreeCommandBuffers-device-parameter]");
2004 disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
2618 "device group count return value.");
2623 // Call down the chain to get the physical device group info.
2837 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
2839 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2842 "vkBindBufferMemory2: Invalid device [VUID-vkBindBufferMemory2-device-parameter]");
2845 return disp->BindBufferMemory2(device, bindInfoCount, pBindInfos);
2848 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
2850 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2853 "vkBindImageMemory2: Invalid device [VUID-vkBindImageMemory2-device-parameter]");
2856 return disp->BindImageMemory2(device, bindInfoCount, pBindInfos);
2859 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
2862 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2865 "vkGetDeviceGroupPeerMemoryFeatures: Invalid device [VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter]");
2868 disp->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
2893 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
2895 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2898 "vkGetImageMemoryRequirements2: Invalid device [VUID-vkGetImageMemoryRequirements2-device-parameter]");
2901 disp->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
2904 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device,
2907 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2910 "vkGetBufferMemoryRequirements2: Invalid device [VUID-vkGetBufferMemoryRequirements2-device-parameter]");
2913 disp->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
2917 VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount,
2919 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2923 "vkGetImageSparseMemoryRequirements2: Invalid device [VUID-vkGetImageSparseMemoryRequirements2-device-parameter]");
2926 disp->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2929 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
2931 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2934 "vkTrimCommandPool: Invalid device [VUID-vkTrimCommandPool-device-parameter]");
2937 disp->TrimCommandPool(device, commandPool, flags);
2940 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
2941 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2944 "vkGetDeviceQueue2: Invalid device [VUID-vkGetDeviceQueue2-device-parameter]");
2947 disp->GetDeviceQueue2(device, pQueueInfo, pQueue);
2953 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device,
2957 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2960 "vkCreateSamplerYcbcrConversion: Invalid device [VUID-vkCreateSamplerYcbcrConversion-device-parameter]");
2963 return disp->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
2966 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
2968 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2971 "vkDestroySamplerYcbcrConversion: Invalid device [VUID-vkDestroySamplerYcbcrConversion-device-parameter]");
2974 disp->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
2977 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device,
2980 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2983 "vkGetDescriptorSetLayoutSupport: Invalid device [VUID-vkGetDescriptorSetLayoutSupport-device-parameter]");
2986 disp->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
2990 vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
2992 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
2995 "vkCreateDescriptorUpdateTemplate: Invalid device [VUID-vkCreateDescriptorUpdateTemplate-device-parameter]");
2998 return disp->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
3001 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device,
3004 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3007 "vkDestroyDescriptorUpdateTemplate: Invalid device [VUID-vkDestroyDescriptorUpdateTemplate-device-parameter]");
3010 disp->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
3013 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet,
3016 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3019 "vkUpdateDescriptorSetWithTemplate: Invalid device [VUID-vkUpdateDescriptorSetWithTemplate-device-parameter]");
3022 disp->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
3027 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo,
3030 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3033 "vkCreateRenderPass2: Invalid device [VUID-vkCreateRenderPass2-device-parameter]");
3036 return disp->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
3100 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) {
3101 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3104 "vkGetSemaphoreCounterValue: Invalid device [VUID-vkGetSemaphoreCounterValue-device-parameter]");
3107 return disp->GetSemaphoreCounterValue(device, semaphore, pValue);
3110 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo,
3112 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3115 "vkWaitSemaphores: Invalid device [VUID-vkWaitSemaphores-device-parameter]");
3118 return disp->WaitSemaphores(device, pWaitInfo, timeout);
3121 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) {
3122 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3125 "vkSignalSemaphore: Invalid device [VUID-vkSignalSemaphore-device-parameter]");
3128 return disp->SignalSemaphore(device, pSignalInfo);
3131 LOADER_EXPORT VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device,
3133 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3136 "vkGetBufferDeviceAddress: Invalid device [VUID-vkGetBufferDeviceAddress-device-parameter]");
3139 return disp->GetBufferDeviceAddress(device, pInfo);
3142 LOADER_EXPORT VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device,
3144 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3147 "vkGetBufferOpaqueCaptureAddress: Invalid device [VUID-vkGetBufferOpaqueCaptureAddress-device-parameter]");
3150 return disp->GetBufferOpaqueCaptureAddress(device, pInfo);
3154 vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) {
3155 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3158 "vkGetDeviceMemoryOpaqueCaptureAddress: Invalid device "
3159 "[VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-parameter]");
3162 return disp->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
3165 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
3167 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3170 "vkResetQueryPool: Invalid device [VUID-vkResetQueryPool-device-parameter]");
3173 disp->ResetQueryPool(device, queryPool, firstQuery, queryCount);
3350 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device,
3354 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3355 return disp->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
3358 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
3360 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3361 disp->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
3364 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device,
3367 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3368 disp->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
3371 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device,
3374 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3375 disp->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
3379 VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount,
3381 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3382 disp->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
3385 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
3387 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3388 disp->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
3391 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
3393 const VkLayerDispatchTable *disp = loader_get_dispatch(device);
3394 return disp->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data);