Ryujinx/moltenvk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Export core names of Vulkan 1.1 calls promoted from extensions.

Browse Source 
The functions are now defined under their core names. To avoid code
bloat, I've defined the suffixed names as aliases of the core names.
Both symbols will be globally defined with the same value, and in the
dylib both will be exported.

Fix the default API version when none is given. Zero is the same as
`VK_API_VERSION_1_0`. Prior to this, we were overwriting it with zero if
no app info were given, or if it were zero in the app info. It wasn't
important before, but now that we gate API availability on maximum
Vulkan version, we need to make sure it's a valid version.
This commit is contained in:
Chip Davis 2020-09-03 02:02:24 -05:00
parent 16db5bfe63
commit 78963db6cc
5 changed files with 331 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Common/MVKCommonEnvironment.h
View File

@ -75,6 +75,9 @@ extern "C" {
/** Directive to identify public symbols. */
#define MVK_PUBLIC_SYMBOL __attribute__((visibility("default")))
/** Directive to make a public alias of another symbol. */
#define MVK_PUBLIC_ALIAS(a, t) asm(".globl _" #a "; _" #a " = _" #t "\n")
#ifdef __cplusplus
}

7
MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
View File

@ -2382,10 +2382,11 @@ MVKPhysicalDevice::~MVKPhysicalDevice() {
// Returns core device commands and enabled extension device commands.
PFN_vkVoidFunction MVKDevice::getProcAddr(const char* pName) {
MVKEntryPoint* pMVKPA = _physicalDevice->_mvkInstance->getEntryPoint(pName);
uint32_t apiVersion = _physicalDevice->_mvkInstance->_appInfo.apiVersion;
bool isSupported = (pMVKPA && // Command exists and...
pMVKPA->isDevice && // ...is a device command and...
pMVKPA->isEnabled(_enabledExtensions)); // ...is a core or enabled extension command.
bool isSupported = (pMVKPA && // Command exists and...
pMVKPA->isDevice && // ...is a device command and...
pMVKPA->isEnabled(apiVersion, _enabledExtensions)); // ...is a core or enabled extension command.
return isSupported ? pMVKPA->functionPointer : nullptr;
}

6
MoltenVK/MoltenVK/GPUObjects/MVKInstance.h
View File

@ -37,13 +37,15 @@ class MVKDebugUtilsMessenger;
/** Tracks info about entry point function pointer addresses. */
typedef struct {
PFN_vkVoidFunction functionPointer;
uint32_t apiVersion;
const char* ext1Name;
const char* ext2Name;
bool isDevice;
bool isCore() { return !ext1Name && !ext2Name; }
bool isEnabled(const MVKExtensionList& extList) {
return isCore() || extList.isEnabled(ext1Name) || extList.isEnabled(ext2Name);
bool isEnabled(uint32_t enabledVersion, const MVKExtensionList& extList) {
return (isCore() && MVK_VULKAN_API_VERSION_CONFORM(enabledVersion) >= apiVersion) ||
extList.isEnabled(ext1Name) || extList.isEnabled(ext2Name);
}
} MVKEntryPoint;

53
MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm
View File

@ -39,9 +39,9 @@ MVKEntryPoint* MVKInstance::getEntryPoint(const char* pName) {
PFN_vkVoidFunction MVKInstance::getProcAddr(const char* pName) {
MVKEntryPoint* pMVKPA = getEntryPoint(pName);
bool isSupported = (pMVKPA && // Command exists and...
(pMVKPA->isDevice || // ...is a device command or...
pMVKPA->isEnabled(_enabledExtensions))); // ...is a core or enabled extension command.
bool isSupported = (pMVKPA && // Command exists and...
(pMVKPA->isDevice || // ...is a device command or...
pMVKPA->isEnabled(_appInfo.apiVersion, _enabledExtensions))); // ...is a core or enabled extension command.
return isSupported ? pMVKPA->functionPointer : nullptr;
}
@ -336,8 +336,8 @@ MVKInstance::MVKInstance(const VkInstanceCreateInfo* pCreateInfo) : _enabledExte
initDebugCallbacks(pCreateInfo); // Do before any creation activities
_appInfo.apiVersion = MVK_VULKAN_API_VERSION; // Default
mvkSetOrClear(&_appInfo, pCreateInfo->pApplicationInfo);
if (_appInfo.apiVersion == 0) { _appInfo.apiVersion = VK_API_VERSION_1_0; } // Default
initProcAddrs(); // Init function pointers
initConfig();
@ -403,16 +403,19 @@ void MVKInstance::initDebugCallbacks(const VkInstanceCreateInfo* pCreateInfo) {
}
}
#define ADD_ENTRY_POINT(func, ext1, ext2, isDev) _entryPoints[""#func] = { (PFN_vkVoidFunction)&func, ext1, ext2, isDev }
#define ADD_ENTRY_POINT(func, api, ext1, ext2, isDev) _entryPoints[""#func] = { (PFN_vkVoidFunction)&func, api, ext1, ext2, isDev }
#define ADD_INST_ENTRY_POINT(func) ADD_ENTRY_POINT(func, nullptr, nullptr, false)
#define ADD_DVC_ENTRY_POINT(func) ADD_ENTRY_POINT(func, nullptr, nullptr, true)
#define ADD_INST_ENTRY_POINT(func) ADD_ENTRY_POINT(func, VK_API_VERSION_1_0, nullptr, nullptr, false)
#define ADD_DVC_ENTRY_POINT(func) ADD_ENTRY_POINT(func, VK_API_VERSION_1_0, nullptr, nullptr, true)
#define ADD_INST_EXT_ENTRY_POINT(func, EXT) ADD_ENTRY_POINT(func, VK_ ##EXT ##_EXTENSION_NAME, nullptr, false)
#define ADD_DVC_EXT_ENTRY_POINT(func, EXT) ADD_ENTRY_POINT(func, VK_ ##EXT ##_EXTENSION_NAME, nullptr, true)
#define ADD_INST_1_1_ENTRY_POINT(func) ADD_ENTRY_POINT(func, VK_API_VERSION_1_1, nullptr, nullptr, false)
#define ADD_DVC_1_1_ENTRY_POINT(func) ADD_ENTRY_POINT(func, VK_API_VERSION_1_1, nullptr, nullptr, true)
#define ADD_INST_EXT2_ENTRY_POINT(func, EXT1, EXT2) ADD_ENTRY_POINT(func, VK_ ##EXT1 ##_EXTENSION_NAME, VK_ ##EXT2 ##_EXTENSION_NAME, false)
#define ADD_DVC_EXT2_ENTRY_POINT(func, EXT1, EXT2) ADD_ENTRY_POINT(func, VK_ ##EXT1 ##_EXTENSION_NAME, VK_ ##EXT2 ##_EXTENSION_NAME, true)
#define ADD_INST_EXT_ENTRY_POINT(func, EXT) ADD_ENTRY_POINT(func, 0, VK_ ##EXT ##_EXTENSION_NAME, nullptr, false)
#define ADD_DVC_EXT_ENTRY_POINT(func, EXT) ADD_ENTRY_POINT(func, 0, VK_ ##EXT ##_EXTENSION_NAME, nullptr, true)
#define ADD_INST_EXT2_ENTRY_POINT(func, EXT1, EXT2) ADD_ENTRY_POINT(func, 0, VK_ ##EXT1 ##_EXTENSION_NAME, VK_ ##EXT2 ##_EXTENSION_NAME, false)
#define ADD_DVC_EXT2_ENTRY_POINT(func, EXT1, EXT2) ADD_ENTRY_POINT(func, 0, VK_ ##EXT1 ##_EXTENSION_NAME, VK_ ##EXT2 ##_EXTENSION_NAME, true)
// Initializes the function pointer map.
void MVKInstance::initProcAddrs() {
@ -432,6 +435,18 @@ void MVKInstance::initProcAddrs() {
ADD_INST_ENTRY_POINT(vkEnumerateDeviceLayerProperties);
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties);
ADD_INST_1_1_ENTRY_POINT(vkEnumeratePhysicalDeviceGroups);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceFeatures2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceFormatProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceImageFormatProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceQueueFamilyProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceMemoryProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties2);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceExternalFenceProperties);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceExternalBufferProperties);
ADD_INST_1_1_ENTRY_POINT(vkGetPhysicalDeviceExternalSemaphoreProperties);
// Device functions:
ADD_DVC_ENTRY_POINT(vkGetDeviceProcAddr);
ADD_DVC_ENTRY_POINT(vkDestroyDevice);
@ -555,6 +570,22 @@ void MVKInstance::initProcAddrs() {
ADD_DVC_ENTRY_POINT(vkCmdEndRenderPass);
ADD_DVC_ENTRY_POINT(vkCmdExecuteCommands);
ADD_DVC_1_1_ENTRY_POINT(vkBindBufferMemory2);
ADD_DVC_1_1_ENTRY_POINT(vkBindImageMemory2);
ADD_DVC_1_1_ENTRY_POINT(vkGetBufferMemoryRequirements2);
ADD_DVC_1_1_ENTRY_POINT(vkGetImageMemoryRequirements2);
ADD_DVC_1_1_ENTRY_POINT(vkGetImageSparseMemoryRequirements2);
ADD_DVC_1_1_ENTRY_POINT(vkGetDeviceGroupPeerMemoryFeatures);
ADD_DVC_1_1_ENTRY_POINT(vkCreateDescriptorUpdateTemplate);
ADD_DVC_1_1_ENTRY_POINT(vkDestroyDescriptorUpdateTemplate);
ADD_DVC_1_1_ENTRY_POINT(vkUpdateDescriptorSetWithTemplate);
ADD_DVC_1_1_ENTRY_POINT(vkGetDescriptorSetLayoutSupport);
ADD_DVC_1_1_ENTRY_POINT(vkCreateSamplerYcbcrConversion);
ADD_DVC_1_1_ENTRY_POINT(vkDestroySamplerYcbcrConversion);
ADD_DVC_1_1_ENTRY_POINT(vkTrimCommandPool);
ADD_DVC_1_1_ENTRY_POINT(vkCmdSetDeviceMask);
ADD_DVC_1_1_ENTRY_POINT(vkCmdDispatchBase);
// Instance extension functions:
ADD_INST_EXT_ENTRY_POINT(vkEnumeratePhysicalDeviceGroupsKHR, KHR_DEVICE_GROUP_CREATION);
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceExternalFencePropertiesKHR, KHR_EXTERNAL_FENCE_CAPABILITIES);

511
MoltenVK/MoltenVK/Vulkan/vulkan.mm
View File

@ -158,9 +158,12 @@ static inline void MVKTraceVulkanCallEndImpl(const char* funcName, uint64_t star
MVKAddCmd(baseCmdType ##Multi, vkCmdBuff, ##__VA_ARGS__); \
}
// Define an extension call as an alias of a core call
#define MVK_PUBLIC_CORE_ALIAS(vkf) MVK_PUBLIC_ALIAS(vkf##KHR, vkf)
#pragma mark -
#pragma mark Vulkan calls
#pragma mark Vulkan 1.0 calls
MVK_PUBLIC_SYMBOL VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
@ -1900,12 +1903,136 @@ MVK_PUBLIC_SYMBOL void vkCmdExecuteCommands(
#pragma mark -
#pragma mark VK_KHR_bind_memory2 extension
#pragma mark Vulkan 1.1 calls
MVK_PUBLIC_SYMBOL VkResult vkBindBufferMemory2KHR(
MVK_PUBLIC_SYMBOL VkResult vkEnumeratePhysicalDeviceGroups(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
MVKTraceVulkanCallStart();
MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
VkResult rslt = mvkInst->getPhysicalDeviceGroups(pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceFeatures2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getFeatures(pFeatures);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getProperties(pProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceFormatProperties2(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2* pFormatProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getFormatProperties(format, pFormatProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
VkResult rslt = mvkPD->getImageFormatProperties(pImageFormatInfo, pImageFormatProperties);
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getQueueFamilyProperties(pQueueFamilyPropertyCount, pQueueFamilyProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getMemoryProperties(pMemoryProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2* pProperties) {
MVKTraceVulkanCallStart();
// Metal does not support sparse images.
// Vulkan spec: "If VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT is not supported for the given arguments,
// pPropertyCount will be set to zero upon return, and no data will be written to pProperties.".
*pPropertyCount = 0;
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalFenceProperties(pExternalFenceInfo, pExternalFenceProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalBufferProperties(pExternalBufferInfo, pExternalBufferProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalSemaphoreProperties(pExternalSemaphoreInfo, pExternalSemaphoreProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL VkResult vkBindBufferMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfoKHR* pBindInfos) {
const VkBindBufferMemoryInfo* pBindInfos) {
MVKTraceVulkanCallStart();
VkResult rslt = VK_SUCCESS;
@ -1918,10 +2045,10 @@ MVK_PUBLIC_SYMBOL VkResult vkBindBufferMemory2KHR(
return rslt;
}
MVK_PUBLIC_SYMBOL VkResult vkBindImageMemory2KHR(
MVK_PUBLIC_SYMBOL VkResult vkBindImageMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfoKHR* pBindInfos) {
const VkBindImageMemoryInfo* pBindInfos) {
MVKTraceVulkanCallStart();
VkResult rslt = VK_SUCCESS;
@ -1934,29 +2061,76 @@ MVK_PUBLIC_SYMBOL VkResult vkBindImageMemory2KHR(
return rslt;
}
MVK_PUBLIC_SYMBOL void vkGetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
#pragma mark -
#pragma mark VK_KHR_descriptor_update_template extension
MVKTraceVulkanCallStart();
MVKBuffer* mvkBuff = (MVKBuffer*)pInfo->buffer;
mvkBuff->getMemoryRequirements(pInfo, pMemoryRequirements);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL VkResult vkCreateDescriptorUpdateTemplateKHR(
MVK_PUBLIC_SYMBOL void vkGetImageMemoryRequirements2(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
MVKTraceVulkanCallStart();
auto* mvkImg = (MVKImage*)pInfo->image;
mvkImg->getMemoryRequirements(pInfo, pMemoryRequirements);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
MVKTraceVulkanCallStart();
// Metal does not support sparse images.
// Vulkan spec: "If the image was not created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT then
// pSparseMemoryRequirementCount will be set to zero and pSparseMemoryRequirements will not be written to.".
*pSparseMemoryRequirementCount = 0;
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetDeviceGroupPeerMemoryFeatures(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
mvkDev->getPeerMemoryFeatures(heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL VkResult vkCreateDescriptorUpdateTemplate(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) {
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
auto *mvkDUT = mvkDev->createDescriptorUpdateTemplate(pCreateInfo,
pAllocator);
*pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)mvkDUT;
*pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)mvkDUT;
VkResult rslt = mvkDUT->getConfigurationResult();
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkDestroyDescriptorUpdateTemplateKHR(
MVK_PUBLIC_SYMBOL void vkDestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
MVKTraceVulkanCallStart();
@ -1965,10 +2139,10 @@ MVK_PUBLIC_SYMBOL void vkDestroyDescriptorUpdateTemplateKHR(
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkUpdateDescriptorSetWithTemplateKHR(
MVK_PUBLIC_SYMBOL void vkUpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData) {
MVKTraceVulkanCallStart();
@ -1976,24 +2150,56 @@ MVK_PUBLIC_SYMBOL void vkUpdateDescriptorSetWithTemplateKHR(
MVKTraceVulkanCallEnd();
}
#pragma mark -
#pragma mark VK_KHR_device_group extension
MVK_PUBLIC_SYMBOL void vkGetDeviceGroupPeerMemoryFeaturesKHR(
MVK_PUBLIC_SYMBOL void vkGetDescriptorSetLayoutSupport(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) {
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
mvkDev->getPeerMemoryFeatures(heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
MVKTraceVulkanCallEnd();
MVKTraceVulkanCallStart();
MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
mvkDevice->getDescriptorSetLayoutSupport(pCreateInfo, pSupport);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkCmdSetDeviceMaskKHR(
MVK_PUBLIC_SYMBOL VkResult vkCreateSamplerYcbcrConversion(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
MVKSamplerYcbcrConversion* mvkSampConv = mvkDev->createSamplerYcbcrConversion(pCreateInfo, pAllocator);
*pYcbcrConversion = (VkSamplerYcbcrConversion)mvkSampConv;
VkResult rslt = mvkSampConv->getConfigurationResult();
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkDestroySamplerYcbcrConversion(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
MVKTraceVulkanCallStart();
if ( !ycbcrConversion ) { return; }
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
mvkDev->destroySamplerYcbcrConversion((MVKSamplerYcbcrConversion*)ycbcrConversion, pAllocator);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkTrimCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
MVKTraceVulkanCallStart();
MVKCommandPool* mvkCmdPool = (MVKCommandPool*)commandPool;
mvkCmdPool->trim();
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkCmdSetDeviceMask(
VkCommandBuffer commandBuffer,
uint32_t deviceMask) {
@ -2003,7 +2209,7 @@ MVK_PUBLIC_SYMBOL void vkCmdSetDeviceMaskKHR(
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkCmdDispatchBaseKHR(
MVK_PUBLIC_SYMBOL void vkCmdDispatchBase(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
@ -2018,220 +2224,83 @@ MVK_PUBLIC_SYMBOL void vkCmdDispatchBaseKHR(
}
#pragma mark -
#pragma mark VK_KHR_bind_memory2 extension
MVK_PUBLIC_CORE_ALIAS(vkBindBufferMemory2);
MVK_PUBLIC_CORE_ALIAS(vkBindImageMemory2);
#pragma mark -
#pragma mark VK_KHR_descriptor_update_template extension
MVK_PUBLIC_CORE_ALIAS(vkCreateDescriptorUpdateTemplate);
MVK_PUBLIC_CORE_ALIAS(vkDestroyDescriptorUpdateTemplate);
MVK_PUBLIC_CORE_ALIAS(vkUpdateDescriptorSetWithTemplate);
#pragma mark -
#pragma mark VK_KHR_device_group extension
MVK_PUBLIC_CORE_ALIAS(vkGetDeviceGroupPeerMemoryFeatures);
MVK_PUBLIC_CORE_ALIAS(vkCmdSetDeviceMask);
MVK_PUBLIC_CORE_ALIAS(vkCmdDispatchBase);
#pragma mark -
#pragma mark VK_KHR_device_group_creation extension
MVK_PUBLIC_SYMBOL VkResult vkEnumeratePhysicalDeviceGroupsKHR(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) {
MVKTraceVulkanCallStart();
MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
VkResult rslt = mvkInst->getPhysicalDeviceGroups(pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_CORE_ALIAS(vkEnumeratePhysicalDeviceGroups);
#pragma mark -
#pragma mark VK_KHR_external_fence_capabilities extension
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalFencePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalFenceProperties(pExternalFenceInfo, pExternalFenceProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceExternalFenceProperties);
#pragma mark -
#pragma mark VK_KHR_external_memory_capabilities extension
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalBufferProperties(pExternalBufferInfo, pExternalBufferProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceExternalBufferProperties);
#pragma mark -
#pragma mark VK_KHR_external_semaphore_capabilities extension
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getExternalSemaphoreProperties(pExternalSemaphoreInfo, pExternalSemaphoreProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceExternalSemaphoreProperties);
#pragma mark -
#pragma mark VK_KHR_get_memory_requirements2 extension
MVK_PUBLIC_SYMBOL void vkGetBufferMemoryRequirements2KHR(
VkDevice device,
const VkBufferMemoryRequirementsInfo2KHR* pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) {
MVKTraceVulkanCallStart();
MVKBuffer* mvkBuff = (MVKBuffer*)pInfo->buffer;
mvkBuff->getMemoryRequirements(pInfo, pMemoryRequirements);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetImageMemoryRequirements2KHR(
VkDevice device,
const VkImageMemoryRequirementsInfo2KHR* pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) {
MVKTraceVulkanCallStart();
auto* mvkImg = (MVKImage*)pInfo->image;
mvkImg->getMemoryRequirements(pInfo, pMemoryRequirements);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetImageSparseMemoryRequirements2KHR(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) {
MVKTraceVulkanCallStart();
// Metal does not support sparse images.
// Vulkan spec: "If the image was not created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT then
// pSparseMemoryRequirementCount will be set to zero and pSparseMemoryRequirements will not be written to.".
*pSparseMemoryRequirementCount = 0;
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetBufferMemoryRequirements2);
MVK_PUBLIC_CORE_ALIAS(vkGetImageMemoryRequirements2);
MVK_PUBLIC_CORE_ALIAS(vkGetImageSparseMemoryRequirements2);
#pragma mark -
#pragma mark VK_KHR_get_physical_device_properties2 extension
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceFeatures2KHR(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2KHR* pFeatures) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getFeatures(pFeatures);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceProperties2KHR(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2KHR* pProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getProperties(pProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2KHR* pFormatProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getFormatProperties(format, pFormatProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
VkImageFormatProperties2KHR* pImageFormatProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
VkResult rslt = mvkPD->getImageFormatProperties(pImageFormatInfo, pImageFormatProperties);
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR* pQueueFamilyProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getQueueFamilyProperties(pQueueFamilyPropertyCount, pQueueFamilyProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceMemoryProperties2KHR(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) {
MVKTraceVulkanCallStart();
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
mvkPD->getMemoryProperties(pMemoryProperties);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_SYMBOL void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2KHR* pProperties) {
MVKTraceVulkanCallStart();
// Metal does not support sparse images.
// Vulkan spec: "If VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT is not supported for the given arguments,
// pPropertyCount will be set to zero upon return, and no data will be written to pProperties.".
*pPropertyCount = 0;
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceFeatures2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceProperties2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceFormatProperties2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceImageFormatProperties2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceQueueFamilyProperties2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceMemoryProperties2);
MVK_PUBLIC_CORE_ALIAS(vkGetPhysicalDeviceSparseImageFormatProperties2);
#pragma mark -
#pragma mark VK_KHR_maintenance1 extension
MVK_PUBLIC_SYMBOL void vkTrimCommandPoolKHR(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlagsKHR flags) {
MVKTraceVulkanCallStart();
MVKCommandPool* mvkCmdPool = (MVKCommandPool*)commandPool;
mvkCmdPool->trim();
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkTrimCommandPool);
#pragma mark -
#pragma mark VK_KHR_maintenance3 extension
MVK_PUBLIC_SYMBOL void vkGetDescriptorSetLayoutSupportKHR(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupportKHR* pSupport) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
mvkDevice->getDescriptorSetLayoutSupport(pCreateInfo, pSupport);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkGetDescriptorSetLayoutSupport);
#pragma mark -
@ -2266,32 +2335,8 @@ MVK_PUBLIC_SYMBOL void vkCmdPushDescriptorSetWithTemplateKHR(
#pragma mark -
#pragma mark VK_KHR_sampler_ycbcr_conversion extension
MVK_PUBLIC_SYMBOL VkResult vkCreateSamplerYcbcrConversionKHR(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion) {
MVKTraceVulkanCallStart();
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
MVKSamplerYcbcrConversion* mvkSampConv = mvkDev->createSamplerYcbcrConversion(pCreateInfo, pAllocator);
*pYcbcrConversion = (VkSamplerYcbcrConversion)mvkSampConv;
VkResult rslt = mvkSampConv->getConfigurationResult();
MVKTraceVulkanCallEnd();
return rslt;
}
MVK_PUBLIC_SYMBOL void vkDestroySamplerYcbcrConversionKHR(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
MVKTraceVulkanCallStart();
if ( !ycbcrConversion ) { return; }
MVKDevice* mvkDev = MVKDevice::getMVKDevice(device);
mvkDev->destroySamplerYcbcrConversion((MVKSamplerYcbcrConversion*)ycbcrConversion, pAllocator);
MVKTraceVulkanCallEnd();
}
MVK_PUBLIC_CORE_ALIAS(vkCreateSamplerYcbcrConversion);
MVK_PUBLIC_CORE_ALIAS(vkDestroySamplerYcbcrConversion);
#pragma mark -