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

Merge pull request #532 from billhollings/master

Browse Source 
Add correct function entry point handling.
This commit is contained in:
Bill Hollings 2019-03-21 10:27:34 -04:00 committed by GitHub
commit 9a14df85af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 459 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Docs/MoltenVK_Runtime_UserGuide.md
View File

@ -233,6 +233,7 @@ In addition to the core *Vulkan* API, **MoltenVK** also supports the following
- `VK_KHR_descriptor_update_template` - `VK_KHR_descriptor_update_template`
- `VK_KHR_get_memory_requirements2` - `VK_KHR_get_memory_requirements2`
- `VK_KHR_get_physical_device_properties2` - `VK_KHR_get_physical_device_properties2`
- `VK_KHR_get_surface_capabilities2`
- `VK_KHR_image_format_list` - `VK_KHR_image_format_list`
- `VK_KHR_maintenance1` - `VK_KHR_maintenance1`
- `VK_KHR_maintenance2` - `VK_KHR_maintenance2`

6
Docs/Whats_New.md
View File

@ -19,7 +19,11 @@ MoltenVK 1.0.34
Released TBD Released TBD
- Add support for tessellation. - Add support for tessellation.
- Allow zero offset and stride combo in VkVertexInputBindingDescription. - Add correct function entry point handling.
- Add support for `VK_KHR_get_surface_capabilities2` extension.
- Implement newer `VK_KHR_swapchain` extension functions.
- Allow zero offset and stride combo in `VkVertexInputBindingDescription`.
- Fix conditions when multiple functions return VK_INCOMPLETE.
- Fix potential memory leak on synchronous command buffer submission. - Fix potential memory leak on synchronous command buffer submission.
- Increase shader float constant accuracy beyond 6 digits of precision. - Increase shader float constant accuracy beyond 6 digits of precision.
- MoltenVKShaderConverterTool support cs & csh for compute shader file extensions. - MoltenVKShaderConverterTool support cs & csh for compute shader file extensions.

59
MoltenVK/MoltenVK/GPUObjects/MVKDevice.h
View File

@ -132,8 +132,7 @@ public:
VkResult getSurfaceCapabilities(MVKSurface* surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); VkResult getSurfaceCapabilities(MVKSurface* surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
/** /**
* Returns the pixel formats supported by the surface described by the specified * Returns the pixel formats supported by the surface.
* surface description.
* *
* If pSurfaceFormats is null, the value of pCount is updated with the number of * If pSurfaceFormats is null, the value of pCount is updated with the number of
* pixel formats supported by the surface. * pixel formats supported by the surface.
@ -148,8 +147,22 @@ public:
VkResult getSurfaceFormats(MVKSurface* surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats); VkResult getSurfaceFormats(MVKSurface* surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats);
/** /**
* Returns the presentation modes supported by the surface described by the specified * Returns the pixel formats supported by the surface.
* surface description. *
* If pSurfaceFormats is null, the value of pCount is updated with the number of
* pixel formats supported by the surface.
*
* If pSurfaceFormats is not null, then pCount formats are copied into the array.
* If the number of available formats is less than pCount, the value of pCount is
* updated to indicate the number of formats actually returned in the array.
*
* Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of supported
* formats is larger than pCount. Returns other values if an error occurs.
*/
VkResult getSurfaceFormats(MVKSurface* surface, uint32_t* pCount, VkSurfaceFormat2KHR* pSurfaceFormats);
/**
* Returns the presentation modes supported by the surface.
* *
* If pPresentModes is null, the value of pCount is updated with the number of * If pPresentModes is null, the value of pCount is updated with the number of
* presentation modes supported by the surface. * presentation modes supported by the surface.
@ -163,36 +176,52 @@ public:
*/ */
VkResult getSurfacePresentModes(MVKSurface* surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes); VkResult getSurfacePresentModes(MVKSurface* surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes);
/**
* Returns the rectangles that will be used on the surface by this physical device
* when the surface is presented.
*
* If pRects is null, the value of pRectCount is updated with the number of
* rectangles used the surface by this physical device.
*
* If pRects is not null, then pCount rectangles are copied into the array.
* If the number of rectangles is less than pCount, the value of pCount is updated
* to indicate the number of rectangles actually returned in the array.
*
* Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of rectangles
* is larger than pCount. Returns other values if an error occurs.
*/
VkResult getPresentRectangles(MVKSurface* surface, uint32_t* pRectCount, VkRect2D* pRects);
#pragma mark Queues #pragma mark Queues
/** /**
* If properties is null, the value of pCount is updated with the number of * If pQueueFamilyProperties is null, the value of pCount is updated with the number of
* queue families supported by this instance. * queue families supported by this instance.
* *
* If properties is not null, then pCount queue family properties are copied into the * If pQueueFamilyProperties is not null, then pCount queue family properties are copied into
* array. If the number of available queue families is less than pCount, the value of * the array. If the number of available queue families is less than pCount, the value of
* pCount is updated to indicate the number of queue families actually returned in the array. * pCount is updated to indicate the number of queue families actually returned in the array.
* *
* Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of queue families * Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of queue families
* available in this instance is larger than the specified pCount. Returns other values if * available in this instance is larger than the specified pCount. Returns other values if
* an error occurs. * an error occurs.
*/ */
VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties* properties); VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
/** /**
* If properties is null, the value of pCount is updated with the number of * If pQueueFamilyProperties is null, the value of pCount is updated with the number of
* queue families supported by this instance. * queue families supported by this instance.
* *
* If properties is not null, then pCount queue family properties are copied into the * If pQueueFamilyProperties is not null, then pCount queue family properties are copied into
* array. If the number of available queue families is less than pCount, the value of * the array. If the number of available queue families is less than pCount, the value of
* pCount is updated to indicate the number of queue families actually returned in the array. * pCount is updated to indicate the number of queue families actually returned in the array.
* *
* Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of queue families * Returns VK_SUCCESS if successful. Returns VK_INCOMPLETE if the number of queue families
* available in this instance is larger than the specified pCount. Returns other values if * available in this instance is larger than the specified pCount. Returns other values if
* an error occurs. * an error occurs.
*/ */
VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties2KHR* properties); VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
/** Returns a pointer to the Vulkan instance. */ /** Returns a pointer to the Vulkan instance. */
inline MVKInstance* getInstance() { return _mvkInstance; } inline MVKInstance* getInstance() { return _mvkInstance; }
@ -338,6 +367,12 @@ public:
void getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, void getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport); VkDescriptorSetLayoutSupport* pSupport);
/** Populates the device group presentation capabilities. */
VkResult getDeviceGroupPresentCapabilities(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
/** Populates the device group surface presentation modes. */
VkResult getDeviceGroupSurfacePresentModes(MVKSurface* surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
#pragma mark Object lifecycle #pragma mark Object lifecycle

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

@ -470,7 +470,7 @@ VkResult MVKPhysicalDevice::getSurfaceFormats(MVKSurface* surface,
} }
// Determine how many results we'll return, and return that number // Determine how many results we'll return, and return that number
VkResult result = (*pCount <= mtlFmtsCnt) ? VK_SUCCESS : VK_INCOMPLETE; VkResult result = (*pCount >= mtlFmtsCnt) ? VK_SUCCESS : VK_INCOMPLETE;
*pCount = min(*pCount, mtlFmtsCnt); *pCount = min(*pCount, mtlFmtsCnt);
// Now populate the supplied array // Now populate the supplied array
@ -482,6 +482,27 @@ VkResult MVKPhysicalDevice::getSurfaceFormats(MVKSurface* surface,
return result; return result;
} }
VkResult MVKPhysicalDevice::getSurfaceFormats(MVKSurface* surface,
uint32_t* pCount,
VkSurfaceFormat2KHR* pSurfaceFormats) {
VkResult rslt;
if (pSurfaceFormats) {
// Populate temp array of VkSurfaceFormatKHR then copy into array of VkSurfaceFormat2KHR.
// The value of *pCount may be reduced during call, but will always be <= size of temp array.
VkSurfaceFormatKHR surfFmts[*pCount];
rslt = getSurfaceFormats(surface, pCount, surfFmts);
for (uint32_t fmtIdx = 0; fmtIdx < *pCount; fmtIdx++) {
auto pSF = &pSurfaceFormats[fmtIdx];
pSF->sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
pSF->pNext = nullptr;
pSF->surfaceFormat = surfFmts[fmtIdx];
}
} else {
rslt = getSurfaceFormats(surface, pCount, (VkSurfaceFormatKHR*)nullptr);
}
return rslt;
}
VkResult MVKPhysicalDevice::getSurfacePresentModes(MVKSurface* surface, VkResult MVKPhysicalDevice::getSurfacePresentModes(MVKSurface* surface,
uint32_t* pCount, uint32_t* pCount,
VkPresentModeKHR* pPresentModes) { VkPresentModeKHR* pPresentModes) {
@ -512,6 +533,29 @@ VkResult MVKPhysicalDevice::getSurfacePresentModes(MVKSurface* surface,
return VK_SUCCESS; return VK_SUCCESS;
} }
VkResult MVKPhysicalDevice::getPresentRectangles(MVKSurface* surface,
uint32_t* pRectCount,
VkRect2D* pRects) {
// The layer underlying the surface view must be a CAMetalLayer.
CAMetalLayer* mtlLayer = surface->getCAMetalLayer();
if ( !mtlLayer ) { return surface->getConfigurationResult(); }
if ( !pRects ) {
*pRectCount = 1;
return VK_SUCCESS;
}
if (*pRectCount == 0) { return VK_INCOMPLETE; }
*pRectCount = 1;
pRects[0].offset = { 0, 0 };
pRects[0].extent = mvkVkExtent2DFromCGSize(mtlLayer.naturalDrawableSizeMVK);
return VK_SUCCESS;
}
#pragma mark Queues #pragma mark Queues
@ -552,54 +596,50 @@ vector<MVKQueueFamily*>& MVKPhysicalDevice::getQueueFamilies() {
} }
VkResult MVKPhysicalDevice::getQueueFamilyProperties(uint32_t* pCount, VkResult MVKPhysicalDevice::getQueueFamilyProperties(uint32_t* pCount,
VkQueueFamilyProperties* queueProperties) { VkQueueFamilyProperties* pQueueFamilyProperties) {
vector<MVKQueueFamily*> qFams = getQueueFamilies(); vector<MVKQueueFamily*> qFams = getQueueFamilies();
uint32_t qfCnt = uint32_t(qFams.size()); uint32_t qfCnt = uint32_t(qFams.size());
// If properties aren't actually being requested yet, simply update the returned count // If properties aren't actually being requested yet, simply update the returned count
if ( !queueProperties ) { if ( !pQueueFamilyProperties ) {
*pCount = qfCnt; *pCount = qfCnt;
return VK_SUCCESS; return VK_SUCCESS;
} }
// Determine how many families we'll return, and return that number // Determine how many families we'll return, and return that number
VkResult rslt = (*pCount >= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE;
*pCount = min(*pCount, qfCnt); *pCount = min(*pCount, qfCnt);
// Now populate the queue families // Now populate the queue families
if (queueProperties) { if (pQueueFamilyProperties) {
for (uint32_t qfIdx = 0; qfIdx < *pCount; qfIdx++) { for (uint32_t qfIdx = 0; qfIdx < *pCount; qfIdx++) {
qFams[qfIdx]->getProperties(&queueProperties[qfIdx]); qFams[qfIdx]->getProperties(&pQueueFamilyProperties[qfIdx]);
} }
} }
return (*pCount <= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE; return rslt;
} }
VkResult MVKPhysicalDevice::getQueueFamilyProperties(uint32_t* pCount, VkResult MVKPhysicalDevice::getQueueFamilyProperties(uint32_t* pCount,
VkQueueFamilyProperties2KHR* queueProperties) { VkQueueFamilyProperties2KHR* pQueueFamilyProperties) {
vector<MVKQueueFamily*> qFams = getQueueFamilies(); VkResult rslt;
uint32_t qfCnt = uint32_t(qFams.size()); if (pQueueFamilyProperties) {
// Populate temp array of VkQueueFamilyProperties then copy into array of VkQueueFamilyProperties2KHR.
// If properties aren't actually being requested yet, simply update the returned count // The value of *pCount may be reduced during call, but will always be <= size of temp array.
if ( !queueProperties ) { VkQueueFamilyProperties qProps[*pCount];
*pCount = qfCnt; rslt = getQueueFamilyProperties(pCount, qProps);
return VK_SUCCESS; for (uint32_t qpIdx = 0; qpIdx < *pCount; qpIdx++) {
auto pQP = &pQueueFamilyProperties[qpIdx];
pQP->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
pQP->pNext = nullptr;
pQP->queueFamilyProperties = qProps[qpIdx];
} }
} else {
// Determine how many families we'll return, and return that number rslt = getQueueFamilyProperties(pCount, (VkQueueFamilyProperties*)nullptr);
*pCount = min(*pCount, qfCnt);
// Now populate the queue families
if (queueProperties) {
for (uint32_t qfIdx = 0; qfIdx < *pCount; qfIdx++) {
queueProperties[qfIdx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
qFams[qfIdx]->getProperties(&queueProperties[qfIdx].queueFamilyProperties);
} }
} return rslt;
return (*pCount <= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE;
} }
@ -1509,8 +1549,15 @@ MVKPhysicalDevice::~MVKPhysicalDevice() {
#pragma mark - #pragma mark -
#pragma mark MVKDevice #pragma mark MVKDevice
// Returns core device commands and enabled extension device commands.
PFN_vkVoidFunction MVKDevice::getProcAddr(const char* pName) { PFN_vkVoidFunction MVKDevice::getProcAddr(const char* pName) {
return _physicalDevice->_mvkInstance->getProcAddr(pName); MVKEntryPoint* pMVKPA = _physicalDevice->_mvkInstance->getEntryPoint(pName);
bool isSupported = (pMVKPA && // Command exists and...
pMVKPA->isDevice && // ...is a device command and...
pMVKPA->isEnabled(_enabledExtensions)); // ...is a core or enabled extension command.
return isSupported ? pMVKPA->functionPointer : nullptr;
} }
MVKQueue* MVKDevice::getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) { MVKQueue* MVKDevice::getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) {
@ -1539,6 +1586,20 @@ void MVKDevice::getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateI
pSupport->supported = (descriptorCount < ((_physicalDevice->_metalFeatures.maxPerStageBufferCount + _physicalDevice->_metalFeatures.maxPerStageTextureCount + _physicalDevice->_metalFeatures.maxPerStageSamplerCount) * 2)); pSupport->supported = (descriptorCount < ((_physicalDevice->_metalFeatures.maxPerStageBufferCount + _physicalDevice->_metalFeatures.maxPerStageTextureCount + _physicalDevice->_metalFeatures.maxPerStageSamplerCount) * 2));
} }
VkResult MVKDevice::getDeviceGroupPresentCapabilities(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
memset(pDeviceGroupPresentCapabilities->presentMask, 0, sizeof(pDeviceGroupPresentCapabilities->presentMask));
pDeviceGroupPresentCapabilities->presentMask[0] = 0x1;
pDeviceGroupPresentCapabilities->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
return VK_SUCCESS;
}
VkResult MVKDevice::getDeviceGroupSurfacePresentModes(MVKSurface* surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
*pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
return VK_SUCCESS;
}
#pragma mark Object lifecycle #pragma mark Object lifecycle

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

@ -27,6 +27,21 @@
#include <string> #include <string>
class MVKPhysicalDevice; class MVKPhysicalDevice;
class MVKDevice;
/** Tracks info about entry point function pointer addresses. */
typedef struct {
PFN_vkVoidFunction functionPointer;
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);
}
} MVKEntryPoint;
#pragma mark - #pragma mark -
@ -37,8 +52,8 @@ class MVKInstance : public MVKDispatchableObject {
public: public:
/** Returns the function pointer corresponding to the specified named entry point. */ /** Returns the function pointer corresponding to the named entry point, or NULL if it doesn't exist. */
inline PFN_vkVoidFunction getProcAddr(const char* pName) { return _procAddrMap[pName]; } PFN_vkVoidFunction getProcAddr(const char* pName);
/** /**
* If pPhysicalDevices is null, the value of pCount is updated with the number of * If pPhysicalDevices is null, the value of pCount is updated with the number of
@ -97,7 +112,10 @@ public:
} }
protected: protected:
friend MVKDevice;
void initProcAddrs(); void initProcAddrs();
MVKEntryPoint* getEntryPoint(const char* pName);
void initConfig(); void initConfig();
void logVersions(); void logVersions();
VkResult verifyLayers(uint32_t count, const char* const* names); VkResult verifyLayers(uint32_t count, const char* const* names);
@ -105,6 +123,6 @@ protected:
MVKConfiguration _mvkConfig; MVKConfiguration _mvkConfig;
VkApplicationInfo _appInfo; VkApplicationInfo _appInfo;
std::vector<MVKPhysicalDevice*> _physicalDevices; std::vector<MVKPhysicalDevice*> _physicalDevices;
std::unordered_map<std::string, PFN_vkVoidFunction> _procAddrMap; std::unordered_map<std::string, MVKEntryPoint> _entryPoints;
}; };

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

@ -30,6 +30,22 @@ using namespace std;
#pragma mark - #pragma mark -
#pragma mark MVKInstance #pragma mark MVKInstance
MVKEntryPoint* MVKInstance::getEntryPoint(const char* pName) {
auto iter = _entryPoints.find(pName);
return (iter != _entryPoints.end()) ? &iter->second : nullptr;
}
// Returns core instance commands, enabled instance extension commands, and all device commands.
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.
return isSupported ? pMVKPA->functionPointer : nullptr;
}
VkResult MVKInstance::getPhysicalDevices(uint32_t* pCount, VkPhysicalDevice* pPhysicalDevices) { VkResult MVKInstance::getPhysicalDevices(uint32_t* pCount, VkPhysicalDevice* pPhysicalDevices) {
// Get the number of physical devices // Get the number of physical devices
@ -42,7 +58,7 @@ VkResult MVKInstance::getPhysicalDevices(uint32_t* pCount, VkPhysicalDevice* pPh
} }
// Othewise, determine how many physical devices we'll return, and return that count // Othewise, determine how many physical devices we'll return, and return that count
VkResult result = (*pCount <= pdCnt) ? VK_SUCCESS : VK_INCOMPLETE; VkResult result = (*pCount >= pdCnt) ? VK_SUCCESS : VK_INCOMPLETE;
*pCount = min(pdCnt, *pCount); *pCount = min(pdCnt, *pCount);
// Now populate the devices // Now populate the devices
@ -152,199 +168,217 @@ MVKInstance::MVKInstance(const VkInstanceCreateInfo* pCreateInfo) {
MVKLogInfo("%s", logMsg.c_str()); MVKLogInfo("%s", logMsg.c_str());
} }
#define ADD_PROC_ADDR(entrypoint) _procAddrMap[""#entrypoint] = (PFN_vkVoidFunction)&entrypoint; #define ADD_ENTRY_POINT(func, ext1, ext2, isDev) _entryPoints[""#func] = { (PFN_vkVoidFunction)&func, 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_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_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)
/** Initializes the function pointer map. */ /** Initializes the function pointer map. */
void MVKInstance::initProcAddrs() { void MVKInstance::initProcAddrs() {
// Instance functions // Instance functions
ADD_PROC_ADDR(vkDestroyInstance); ADD_INST_ENTRY_POINT(vkDestroyInstance);
ADD_PROC_ADDR(vkEnumeratePhysicalDevices); ADD_INST_ENTRY_POINT(vkEnumeratePhysicalDevices);
ADD_PROC_ADDR(vkGetPhysicalDeviceFeatures); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceFeatures);
ADD_PROC_ADDR(vkGetPhysicalDeviceFormatProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceFormatProperties);
ADD_PROC_ADDR(vkGetPhysicalDeviceImageFormatProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceImageFormatProperties);
ADD_PROC_ADDR(vkGetPhysicalDeviceProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceProperties);
ADD_PROC_ADDR(vkGetPhysicalDeviceQueueFamilyProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceQueueFamilyProperties);
ADD_PROC_ADDR(vkGetPhysicalDeviceMemoryProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceMemoryProperties);
ADD_PROC_ADDR(vkGetInstanceProcAddr); ADD_INST_ENTRY_POINT(vkGetInstanceProcAddr);
ADD_PROC_ADDR(vkGetDeviceProcAddr); ADD_INST_ENTRY_POINT(vkCreateDevice);
ADD_PROC_ADDR(vkCreateDevice); ADD_INST_ENTRY_POINT(vkEnumerateDeviceExtensionProperties);
ADD_PROC_ADDR(vkEnumerateDeviceExtensionProperties); ADD_INST_ENTRY_POINT(vkEnumerateDeviceLayerProperties);
ADD_PROC_ADDR(vkEnumerateDeviceLayerProperties); ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties);
ADD_PROC_ADDR(vkGetPhysicalDeviceSparseImageFormatProperties);
// Device functions: // Device functions:
ADD_PROC_ADDR(vkDestroyDevice); ADD_DVC_ENTRY_POINT(vkGetDeviceProcAddr);
ADD_PROC_ADDR(vkGetDeviceQueue); ADD_DVC_ENTRY_POINT(vkDestroyDevice);
ADD_PROC_ADDR(vkQueueSubmit); ADD_DVC_ENTRY_POINT(vkGetDeviceQueue);
ADD_PROC_ADDR(vkQueueWaitIdle); ADD_DVC_ENTRY_POINT(vkQueueSubmit);
ADD_PROC_ADDR(vkDeviceWaitIdle); ADD_DVC_ENTRY_POINT(vkQueueWaitIdle);
ADD_PROC_ADDR(vkAllocateMemory); ADD_DVC_ENTRY_POINT(vkDeviceWaitIdle);
ADD_PROC_ADDR(vkFreeMemory); ADD_DVC_ENTRY_POINT(vkAllocateMemory);
ADD_PROC_ADDR(vkMapMemory); ADD_DVC_ENTRY_POINT(vkFreeMemory);
ADD_PROC_ADDR(vkUnmapMemory); ADD_DVC_ENTRY_POINT(vkMapMemory);
ADD_PROC_ADDR(vkFlushMappedMemoryRanges); ADD_DVC_ENTRY_POINT(vkUnmapMemory);
ADD_PROC_ADDR(vkInvalidateMappedMemoryRanges); ADD_DVC_ENTRY_POINT(vkFlushMappedMemoryRanges);
ADD_PROC_ADDR(vkGetDeviceMemoryCommitment); ADD_DVC_ENTRY_POINT(vkInvalidateMappedMemoryRanges);
ADD_PROC_ADDR(vkBindBufferMemory); ADD_DVC_ENTRY_POINT(vkGetDeviceMemoryCommitment);
ADD_PROC_ADDR(vkBindImageMemory); ADD_DVC_ENTRY_POINT(vkBindBufferMemory);
ADD_PROC_ADDR(vkGetBufferMemoryRequirements); ADD_DVC_ENTRY_POINT(vkBindImageMemory);
ADD_PROC_ADDR(vkGetImageMemoryRequirements); ADD_DVC_ENTRY_POINT(vkGetBufferMemoryRequirements);
ADD_PROC_ADDR(vkGetImageSparseMemoryRequirements); ADD_DVC_ENTRY_POINT(vkGetImageMemoryRequirements);
ADD_PROC_ADDR(vkQueueBindSparse); ADD_DVC_ENTRY_POINT(vkGetImageSparseMemoryRequirements);
ADD_PROC_ADDR(vkCreateFence); ADD_DVC_ENTRY_POINT(vkQueueBindSparse);
ADD_PROC_ADDR(vkDestroyFence); ADD_DVC_ENTRY_POINT(vkCreateFence);
ADD_PROC_ADDR(vkResetFences); ADD_DVC_ENTRY_POINT(vkDestroyFence);
ADD_PROC_ADDR(vkGetFenceStatus); ADD_DVC_ENTRY_POINT(vkResetFences);
ADD_PROC_ADDR(vkWaitForFences); ADD_DVC_ENTRY_POINT(vkGetFenceStatus);
ADD_PROC_ADDR(vkCreateSemaphore); ADD_DVC_ENTRY_POINT(vkWaitForFences);
ADD_PROC_ADDR(vkDestroySemaphore); ADD_DVC_ENTRY_POINT(vkCreateSemaphore);
ADD_PROC_ADDR(vkCreateEvent); ADD_DVC_ENTRY_POINT(vkDestroySemaphore);
ADD_PROC_ADDR(vkDestroyEvent); ADD_DVC_ENTRY_POINT(vkCreateEvent);
ADD_PROC_ADDR(vkGetEventStatus); ADD_DVC_ENTRY_POINT(vkDestroyEvent);
ADD_PROC_ADDR(vkSetEvent); ADD_DVC_ENTRY_POINT(vkGetEventStatus);
ADD_PROC_ADDR(vkResetEvent); ADD_DVC_ENTRY_POINT(vkSetEvent);
ADD_PROC_ADDR(vkCreateQueryPool); ADD_DVC_ENTRY_POINT(vkResetEvent);
ADD_PROC_ADDR(vkDestroyQueryPool); ADD_DVC_ENTRY_POINT(vkCreateQueryPool);
ADD_PROC_ADDR(vkGetQueryPoolResults); ADD_DVC_ENTRY_POINT(vkDestroyQueryPool);
ADD_PROC_ADDR(vkCreateBuffer); ADD_DVC_ENTRY_POINT(vkGetQueryPoolResults);
ADD_PROC_ADDR(vkDestroyBuffer); ADD_DVC_ENTRY_POINT(vkCreateBuffer);
ADD_PROC_ADDR(vkCreateBufferView); ADD_DVC_ENTRY_POINT(vkDestroyBuffer);
ADD_PROC_ADDR(vkDestroyBufferView); ADD_DVC_ENTRY_POINT(vkCreateBufferView);
ADD_PROC_ADDR(vkCreateImage); ADD_DVC_ENTRY_POINT(vkDestroyBufferView);
ADD_PROC_ADDR(vkDestroyImage); ADD_DVC_ENTRY_POINT(vkCreateImage);
ADD_PROC_ADDR(vkGetImageSubresourceLayout); ADD_DVC_ENTRY_POINT(vkDestroyImage);
ADD_PROC_ADDR(vkCreateImageView); ADD_DVC_ENTRY_POINT(vkGetImageSubresourceLayout);
ADD_PROC_ADDR(vkDestroyImageView); ADD_DVC_ENTRY_POINT(vkCreateImageView);
ADD_PROC_ADDR(vkCreateShaderModule); ADD_DVC_ENTRY_POINT(vkDestroyImageView);
ADD_PROC_ADDR(vkDestroyShaderModule); ADD_DVC_ENTRY_POINT(vkCreateShaderModule);
ADD_PROC_ADDR(vkCreatePipelineCache); ADD_DVC_ENTRY_POINT(vkDestroyShaderModule);
ADD_PROC_ADDR(vkDestroyPipelineCache); ADD_DVC_ENTRY_POINT(vkCreatePipelineCache);
ADD_PROC_ADDR(vkGetPipelineCacheData); ADD_DVC_ENTRY_POINT(vkDestroyPipelineCache);
ADD_PROC_ADDR(vkMergePipelineCaches); ADD_DVC_ENTRY_POINT(vkGetPipelineCacheData);
ADD_PROC_ADDR(vkCreateGraphicsPipelines); ADD_DVC_ENTRY_POINT(vkMergePipelineCaches);
ADD_PROC_ADDR(vkCreateComputePipelines); ADD_DVC_ENTRY_POINT(vkCreateGraphicsPipelines);
ADD_PROC_ADDR(vkDestroyPipeline); ADD_DVC_ENTRY_POINT(vkCreateComputePipelines);
ADD_PROC_ADDR(vkCreatePipelineLayout); ADD_DVC_ENTRY_POINT(vkDestroyPipeline);
ADD_PROC_ADDR(vkDestroyPipelineLayout); ADD_DVC_ENTRY_POINT(vkCreatePipelineLayout);
ADD_PROC_ADDR(vkCreateSampler); ADD_DVC_ENTRY_POINT(vkDestroyPipelineLayout);
ADD_PROC_ADDR(vkDestroySampler); ADD_DVC_ENTRY_POINT(vkCreateSampler);
ADD_PROC_ADDR(vkCreateDescriptorSetLayout); ADD_DVC_ENTRY_POINT(vkDestroySampler);
ADD_PROC_ADDR(vkDestroyDescriptorSetLayout); ADD_DVC_ENTRY_POINT(vkCreateDescriptorSetLayout);
ADD_PROC_ADDR(vkCreateDescriptorPool); ADD_DVC_ENTRY_POINT(vkDestroyDescriptorSetLayout);
ADD_PROC_ADDR(vkDestroyDescriptorPool); ADD_DVC_ENTRY_POINT(vkCreateDescriptorPool);
ADD_PROC_ADDR(vkResetDescriptorPool); ADD_DVC_ENTRY_POINT(vkDestroyDescriptorPool);
ADD_PROC_ADDR(vkAllocateDescriptorSets); ADD_DVC_ENTRY_POINT(vkResetDescriptorPool);
ADD_PROC_ADDR(vkFreeDescriptorSets); ADD_DVC_ENTRY_POINT(vkAllocateDescriptorSets);
ADD_PROC_ADDR(vkUpdateDescriptorSets); ADD_DVC_ENTRY_POINT(vkFreeDescriptorSets);
ADD_PROC_ADDR(vkCreateFramebuffer); ADD_DVC_ENTRY_POINT(vkUpdateDescriptorSets);
ADD_PROC_ADDR(vkDestroyFramebuffer); ADD_DVC_ENTRY_POINT(vkCreateFramebuffer);
ADD_PROC_ADDR(vkCreateRenderPass); ADD_DVC_ENTRY_POINT(vkDestroyFramebuffer);
ADD_PROC_ADDR(vkDestroyRenderPass); ADD_DVC_ENTRY_POINT(vkCreateRenderPass);
ADD_PROC_ADDR(vkGetRenderAreaGranularity); ADD_DVC_ENTRY_POINT(vkDestroyRenderPass);
ADD_PROC_ADDR(vkCreateCommandPool); ADD_DVC_ENTRY_POINT(vkGetRenderAreaGranularity);
ADD_PROC_ADDR(vkDestroyCommandPool); ADD_DVC_ENTRY_POINT(vkCreateCommandPool);
ADD_PROC_ADDR(vkResetCommandPool); ADD_DVC_ENTRY_POINT(vkDestroyCommandPool);
ADD_PROC_ADDR(vkAllocateCommandBuffers); ADD_DVC_ENTRY_POINT(vkResetCommandPool);
ADD_PROC_ADDR(vkFreeCommandBuffers); ADD_DVC_ENTRY_POINT(vkAllocateCommandBuffers);
ADD_PROC_ADDR(vkBeginCommandBuffer); ADD_DVC_ENTRY_POINT(vkFreeCommandBuffers);
ADD_PROC_ADDR(vkEndCommandBuffer); ADD_DVC_ENTRY_POINT(vkBeginCommandBuffer);
ADD_PROC_ADDR(vkResetCommandBuffer); ADD_DVC_ENTRY_POINT(vkEndCommandBuffer);
ADD_PROC_ADDR(vkCmdBindPipeline); ADD_DVC_ENTRY_POINT(vkResetCommandBuffer);
ADD_PROC_ADDR(vkCmdSetViewport); ADD_DVC_ENTRY_POINT(vkCmdBindPipeline);
ADD_PROC_ADDR(vkCmdSetScissor); ADD_DVC_ENTRY_POINT(vkCmdSetViewport);
ADD_PROC_ADDR(vkCmdSetLineWidth); ADD_DVC_ENTRY_POINT(vkCmdSetScissor);
ADD_PROC_ADDR(vkCmdSetDepthBias); ADD_DVC_ENTRY_POINT(vkCmdSetLineWidth);
ADD_PROC_ADDR(vkCmdSetBlendConstants); ADD_DVC_ENTRY_POINT(vkCmdSetDepthBias);
ADD_PROC_ADDR(vkCmdSetDepthBounds); ADD_DVC_ENTRY_POINT(vkCmdSetBlendConstants);
ADD_PROC_ADDR(vkCmdSetStencilCompareMask); ADD_DVC_ENTRY_POINT(vkCmdSetDepthBounds);
ADD_PROC_ADDR(vkCmdSetStencilWriteMask); ADD_DVC_ENTRY_POINT(vkCmdSetStencilCompareMask);
ADD_PROC_ADDR(vkCmdSetStencilReference); ADD_DVC_ENTRY_POINT(vkCmdSetStencilWriteMask);
ADD_PROC_ADDR(vkCmdBindDescriptorSets); ADD_DVC_ENTRY_POINT(vkCmdSetStencilReference);
ADD_PROC_ADDR(vkCmdBindIndexBuffer); ADD_DVC_ENTRY_POINT(vkCmdBindDescriptorSets);
ADD_PROC_ADDR(vkCmdBindVertexBuffers); ADD_DVC_ENTRY_POINT(vkCmdBindIndexBuffer);
ADD_PROC_ADDR(vkCmdDraw); ADD_DVC_ENTRY_POINT(vkCmdBindVertexBuffers);
ADD_PROC_ADDR(vkCmdDrawIndexed); ADD_DVC_ENTRY_POINT(vkCmdDraw);
ADD_PROC_ADDR(vkCmdDrawIndirect); ADD_DVC_ENTRY_POINT(vkCmdDrawIndexed);
ADD_PROC_ADDR(vkCmdDrawIndexedIndirect); ADD_DVC_ENTRY_POINT(vkCmdDrawIndirect);
ADD_PROC_ADDR(vkCmdDispatch); ADD_DVC_ENTRY_POINT(vkCmdDrawIndexedIndirect);
ADD_PROC_ADDR(vkCmdDispatchIndirect); ADD_DVC_ENTRY_POINT(vkCmdDispatch);
ADD_PROC_ADDR(vkCmdCopyBuffer); ADD_DVC_ENTRY_POINT(vkCmdDispatchIndirect);
ADD_PROC_ADDR(vkCmdCopyImage); ADD_DVC_ENTRY_POINT(vkCmdCopyBuffer);
ADD_PROC_ADDR(vkCmdBlitImage); ADD_DVC_ENTRY_POINT(vkCmdCopyImage);
ADD_PROC_ADDR(vkCmdCopyBufferToImage); ADD_DVC_ENTRY_POINT(vkCmdBlitImage);
ADD_PROC_ADDR(vkCmdCopyImageToBuffer); ADD_DVC_ENTRY_POINT(vkCmdCopyBufferToImage);
ADD_PROC_ADDR(vkCmdUpdateBuffer); ADD_DVC_ENTRY_POINT(vkCmdCopyImageToBuffer);
ADD_PROC_ADDR(vkCmdFillBuffer); ADD_DVC_ENTRY_POINT(vkCmdUpdateBuffer);
ADD_PROC_ADDR(vkCmdClearColorImage); ADD_DVC_ENTRY_POINT(vkCmdFillBuffer);
ADD_PROC_ADDR(vkCmdClearDepthStencilImage); ADD_DVC_ENTRY_POINT(vkCmdClearColorImage);
ADD_PROC_ADDR(vkCmdClearAttachments); ADD_DVC_ENTRY_POINT(vkCmdClearDepthStencilImage);
ADD_PROC_ADDR(vkCmdResolveImage); ADD_DVC_ENTRY_POINT(vkCmdClearAttachments);
ADD_PROC_ADDR(vkCmdSetEvent); ADD_DVC_ENTRY_POINT(vkCmdResolveImage);
ADD_PROC_ADDR(vkCmdResetEvent); ADD_DVC_ENTRY_POINT(vkCmdSetEvent);
ADD_PROC_ADDR(vkCmdWaitEvents); ADD_DVC_ENTRY_POINT(vkCmdResetEvent);
ADD_PROC_ADDR(vkCmdPipelineBarrier); ADD_DVC_ENTRY_POINT(vkCmdWaitEvents);
ADD_PROC_ADDR(vkCmdBeginQuery); ADD_DVC_ENTRY_POINT(vkCmdPipelineBarrier);
ADD_PROC_ADDR(vkCmdEndQuery); ADD_DVC_ENTRY_POINT(vkCmdBeginQuery);
ADD_PROC_ADDR(vkCmdResetQueryPool); ADD_DVC_ENTRY_POINT(vkCmdEndQuery);
ADD_PROC_ADDR(vkCmdWriteTimestamp); ADD_DVC_ENTRY_POINT(vkCmdResetQueryPool);
ADD_PROC_ADDR(vkCmdCopyQueryPoolResults); ADD_DVC_ENTRY_POINT(vkCmdWriteTimestamp);
ADD_PROC_ADDR(vkCmdPushConstants); ADD_DVC_ENTRY_POINT(vkCmdCopyQueryPoolResults);
ADD_PROC_ADDR(vkCmdBeginRenderPass); ADD_DVC_ENTRY_POINT(vkCmdPushConstants);
ADD_PROC_ADDR(vkCmdNextSubpass); ADD_DVC_ENTRY_POINT(vkCmdBeginRenderPass);
ADD_PROC_ADDR(vkCmdEndRenderPass); ADD_DVC_ENTRY_POINT(vkCmdNextSubpass);
ADD_PROC_ADDR(vkCmdExecuteCommands); ADD_DVC_ENTRY_POINT(vkCmdEndRenderPass);
ADD_DVC_ENTRY_POINT(vkCmdExecuteCommands);
// Supported extensions: // Instance extension functions:
ADD_PROC_ADDR(vkBindBufferMemory2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceFeatures2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkBindImageMemory2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkCreateDescriptorUpdateTemplateKHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkDestroyDescriptorUpdateTemplateKHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceImageFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkUpdateDescriptorSetWithTemplateKHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceQueueFamilyProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkGetBufferMemoryRequirements2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceMemoryProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkGetImageMemoryRequirements2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
ADD_PROC_ADDR(vkGetImageSparseMemoryRequirements2KHR); ADD_INST_EXT_ENTRY_POINT(vkDestroySurfaceKHR, KHR_SURFACE);
ADD_PROC_ADDR(vkGetPhysicalDeviceFeatures2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceSupportKHR, KHR_SURFACE);
ADD_PROC_ADDR(vkGetPhysicalDeviceProperties2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, KHR_SURFACE);
ADD_PROC_ADDR(vkGetPhysicalDeviceFormatProperties2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormatsKHR, KHR_SURFACE);
ADD_PROC_ADDR(vkGetPhysicalDeviceImageFormatProperties2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfacePresentModesKHR, KHR_SURFACE);
ADD_PROC_ADDR(vkGetPhysicalDeviceQueueFamilyProperties2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceCapabilities2KHR, KHR_GET_SURFACE_CAPABILITIES_2);
ADD_PROC_ADDR(vkGetPhysicalDeviceMemoryProperties2KHR); ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormats2KHR, KHR_GET_SURFACE_CAPABILITIES_2);
ADD_PROC_ADDR(vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
ADD_PROC_ADDR(vkTrimCommandPoolKHR);
ADD_PROC_ADDR(vkGetDescriptorSetLayoutSupportKHR);
ADD_PROC_ADDR(vkCmdPushDescriptorSetKHR);
ADD_PROC_ADDR(vkCmdPushDescriptorSetWithTemplateKHR);
ADD_PROC_ADDR(vkDestroySurfaceKHR);
ADD_PROC_ADDR(vkGetPhysicalDeviceSurfaceSupportKHR);
ADD_PROC_ADDR(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
ADD_PROC_ADDR(vkGetPhysicalDeviceSurfaceFormatsKHR);
ADD_PROC_ADDR(vkGetPhysicalDeviceSurfacePresentModesKHR);
ADD_PROC_ADDR(vkCreateSwapchainKHR);
ADD_PROC_ADDR(vkDestroySwapchainKHR);
ADD_PROC_ADDR(vkGetSwapchainImagesKHR);
ADD_PROC_ADDR(vkAcquireNextImageKHR);
ADD_PROC_ADDR(vkQueuePresentKHR);
ADD_PROC_ADDR(vkResetQueryPoolEXT);
ADD_PROC_ADDR(vkGetMoltenVKConfigurationMVK);
ADD_PROC_ADDR(vkSetMoltenVKConfigurationMVK);
ADD_PROC_ADDR(vkGetPhysicalDeviceMetalFeaturesMVK);
ADD_PROC_ADDR(vkGetSwapchainPerformanceMVK);
ADD_PROC_ADDR(vkGetPerformanceStatisticsMVK);
ADD_PROC_ADDR(vkGetVersionStringsMVK);
ADD_PROC_ADDR(vkGetMTLDeviceMVK);
ADD_PROC_ADDR(vkSetMTLTextureMVK);
ADD_PROC_ADDR(vkGetMTLTextureMVK);
ADD_PROC_ADDR(vkUseIOSurfaceMVK);
ADD_PROC_ADDR(vkGetIOSurfaceMVK);
#ifdef VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_IOS_MVK
ADD_PROC_ADDR(vkCreateIOSSurfaceMVK); ADD_INST_EXT_ENTRY_POINT(vkCreateIOSSurfaceMVK, MVK_IOS_SURFACE);
#endif #endif
#ifdef VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_MACOS_MVK
ADD_PROC_ADDR(vkCreateMacOSSurfaceMVK); ADD_INST_EXT_ENTRY_POINT(vkCreateMacOSSurfaceMVK, MVK_MACOS_SURFACE);
#endif #endif
ADD_INST_EXT_ENTRY_POINT(vkGetMoltenVKConfigurationMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkSetMoltenVKConfigurationMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceMetalFeaturesMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetSwapchainPerformanceMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetPerformanceStatisticsMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetVersionStringsMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetMTLDeviceMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkSetMTLTextureMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetMTLTextureMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkUseIOSurfaceMVK, MVK_MOLTENVK);
ADD_INST_EXT_ENTRY_POINT(vkGetIOSurfaceMVK, MVK_MOLTENVK);
// Device extension functions:
ADD_DVC_EXT_ENTRY_POINT(vkBindBufferMemory2KHR, KHR_BIND_MEMORY_2);
ADD_DVC_EXT_ENTRY_POINT(vkBindImageMemory2KHR, KHR_BIND_MEMORY_2);
ADD_DVC_EXT_ENTRY_POINT(vkCreateDescriptorUpdateTemplateKHR, KHR_DESCRIPTOR_UPDATE_TEMPLATE);
ADD_DVC_EXT_ENTRY_POINT(vkDestroyDescriptorUpdateTemplateKHR, KHR_DESCRIPTOR_UPDATE_TEMPLATE);
ADD_DVC_EXT_ENTRY_POINT(vkUpdateDescriptorSetWithTemplateKHR, KHR_DESCRIPTOR_UPDATE_TEMPLATE);
ADD_DVC_EXT_ENTRY_POINT(vkGetBufferMemoryRequirements2KHR, KHR_GET_MEMORY_REQUIREMENTS_2);
ADD_DVC_EXT_ENTRY_POINT(vkGetImageMemoryRequirements2KHR, KHR_GET_MEMORY_REQUIREMENTS_2);
ADD_DVC_EXT_ENTRY_POINT(vkGetImageSparseMemoryRequirements2KHR, KHR_GET_MEMORY_REQUIREMENTS_2);
ADD_DVC_EXT_ENTRY_POINT(vkTrimCommandPoolKHR, KHR_MAINTENANCE1);
ADD_DVC_EXT_ENTRY_POINT(vkGetDescriptorSetLayoutSupportKHR, KHR_MAINTENANCE3);
ADD_DVC_EXT_ENTRY_POINT(vkCmdPushDescriptorSetKHR, KHR_PUSH_DESCRIPTOR);
ADD_DVC_EXT2_ENTRY_POINT(vkCmdPushDescriptorSetWithTemplateKHR, KHR_PUSH_DESCRIPTOR, KHR_DESCRIPTOR_UPDATE_TEMPLATE);
ADD_DVC_EXT_ENTRY_POINT(vkCreateSwapchainKHR, KHR_SWAPCHAIN);
ADD_DVC_EXT_ENTRY_POINT(vkDestroySwapchainKHR, KHR_SWAPCHAIN);
ADD_DVC_EXT_ENTRY_POINT(vkGetSwapchainImagesKHR, KHR_SWAPCHAIN);
ADD_DVC_EXT_ENTRY_POINT(vkAcquireNextImageKHR, KHR_SWAPCHAIN);
ADD_DVC_EXT_ENTRY_POINT(vkQueuePresentKHR, KHR_SWAPCHAIN);
ADD_DVC_EXT2_ENTRY_POINT(vkGetDeviceGroupPresentCapabilitiesKHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
ADD_DVC_EXT2_ENTRY_POINT(vkGetDeviceGroupSurfacePresentModesKHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
ADD_DVC_EXT2_ENTRY_POINT(vkGetPhysicalDevicePresentRectanglesKHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
ADD_DVC_EXT2_ENTRY_POINT(vkAcquireNextImage2KHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
ADD_DVC_EXT_ENTRY_POINT(vkResetQueryPoolEXT, EXT_HOST_QUERY_RESET);
} }
void MVKInstance::logVersions() { void MVKInstance::logVersions() {

1
MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.h
View File

@ -57,6 +57,7 @@ public:
VkResult acquireNextImageKHR(uint64_t timeout, VkResult acquireNextImageKHR(uint64_t timeout,
VkSemaphore semaphore, VkSemaphore semaphore,
VkFence fence, VkFence fence,
uint32_t deviceMask,
uint32_t* pImageIndex); uint32_t* pImageIndex);
/** Returns whether the surface size has changed since the last time this function was called. */ /** Returns whether the surface size has changed since the last time this function was called. */

3
MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm
View File

@ -49,7 +49,7 @@ VkResult MVKSwapchain::getImages(uint32_t* pCount, VkImage* pSwapchainImages) {
} }
// Determine how many images we'll return, and return that number // Determine how many images we'll return, and return that number
VkResult result = (*pCount <= imgCnt) ? VK_SUCCESS : VK_INCOMPLETE; VkResult result = (*pCount >= imgCnt) ? VK_SUCCESS : VK_INCOMPLETE;
*pCount = min(*pCount, imgCnt); *pCount = min(*pCount, imgCnt);
// Now populate the images // Now populate the images
@ -63,6 +63,7 @@ VkResult MVKSwapchain::getImages(uint32_t* pCount, VkImage* pSwapchainImages) {
VkResult MVKSwapchain::acquireNextImageKHR(uint64_t timeout, VkResult MVKSwapchain::acquireNextImageKHR(uint64_t timeout,
VkSemaphore semaphore, VkSemaphore semaphore,
VkFence fence, VkFence fence,
uint32_t deviceMask,
uint32_t* pImageIndex) { uint32_t* pImageIndex) {
// Find the image that has the smallest availability measure // Find the image that has the smallest availability measure
uint32_t minWaitIndex = 0; uint32_t minWaitIndex = 0;

2
MoltenVK/MoltenVK/Layers/MVKExtensions.cpp
View File

@ -47,6 +47,8 @@ MVKExtensionList::MVKExtensionList(bool enableForPlatform) :
{} {}
bool MVKExtensionList::isEnabled(const char* extnName) const { bool MVKExtensionList::isEnabled(const char* extnName) const {
if ( !extnName ) { return false; }
uint32_t extnCnt = getCount(); uint32_t extnCnt = getCount();
const MVKExtension* extnAry = &extensionArray; const MVKExtension* extnAry = &extensionArray;
for (uint32_t extnIdx = 0; extnIdx < extnCnt; extnIdx++) { for (uint32_t extnIdx = 0; extnIdx < extnCnt; extnIdx++) {

1
MoltenVK/MoltenVK/Layers/MVKExtensions.def
View File

@ -37,6 +37,7 @@ MVK_EXTENSION(KHR_dedicated_allocation, KHR_DEDICATED_ALLOCATION)
MVK_EXTENSION(KHR_descriptor_update_template, KHR_DESCRIPTOR_UPDATE_TEMPLATE) MVK_EXTENSION(KHR_descriptor_update_template, KHR_DESCRIPTOR_UPDATE_TEMPLATE)
MVK_EXTENSION(KHR_get_memory_requirements2, KHR_GET_MEMORY_REQUIREMENTS_2) MVK_EXTENSION(KHR_get_memory_requirements2, KHR_GET_MEMORY_REQUIREMENTS_2)
MVK_EXTENSION(KHR_get_physical_device_properties2, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2) MVK_EXTENSION(KHR_get_physical_device_properties2, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2)
MVK_EXTENSION(KHR_get_surface_capabilities2, KHR_GET_SURFACE_CAPABILITIES_2)
MVK_EXTENSION(KHR_image_format_list, KHR_IMAGE_FORMAT_LIST) MVK_EXTENSION(KHR_image_format_list, KHR_IMAGE_FORMAT_LIST)
MVK_EXTENSION(KHR_maintenance1, KHR_MAINTENANCE1) MVK_EXTENSION(KHR_maintenance1, KHR_MAINTENANCE1)
MVK_EXTENSION(KHR_maintenance2, KHR_MAINTENANCE2) MVK_EXTENSION(KHR_maintenance2, KHR_MAINTENANCE2)

2
MoltenVK/MoltenVK/Layers/MVKLayers.mm
View File

@ -100,7 +100,7 @@ VkResult MVKLayerManager::getLayerProperties(uint32_t* pCount, VkLayerProperties
// Othewise, determine how many layers we'll return, and return that count // Othewise, determine how many layers we'll return, and return that count
uint32_t layerCnt = (uint32_t)_layers.size(); uint32_t layerCnt = (uint32_t)_layers.size();
VkResult result = (*pCount <= layerCnt) ? VK_SUCCESS : VK_INCOMPLETE; VkResult result = (*pCount >= layerCnt) ? VK_SUCCESS : VK_INCOMPLETE;
*pCount = min(layerCnt, *pCount); *pCount = min(layerCnt, *pCount);
// Now populate the layer properties // Now populate the layer properties

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

@ -132,16 +132,14 @@ MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetInstanceProcAddr(
VkInstance instance, VkInstance instance,
const char* pName) { const char* pName) {
// Handle the function that creates an instance specially. // Handle the special platform functions where the instance parameter may be NULL.
// In this case, the instance parameter is ignored and may be NULL.
if (strcmp(pName, "vkCreateInstance") == 0) { return (PFN_vkVoidFunction)vkCreateInstance; } if (strcmp(pName, "vkCreateInstance") == 0) { return (PFN_vkVoidFunction)vkCreateInstance; }
if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; } if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; }
if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; } if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; }
if (instance) { if ( !instance ) { return nullptr; }
MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance); MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
return mvkInst->getProcAddr(pName); return mvkInst->getProcAddr(pName);
}
return NULL;
} }
MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetDeviceProcAddr( MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetDeviceProcAddr(
@ -1648,6 +1646,7 @@ MVK_PUBLIC_SYMBOL void vkTrimCommandPoolKHR(
VkDevice device, VkDevice device,
VkCommandPool commandPool, VkCommandPool commandPool,
VkCommandPoolTrimFlagsKHR flags) { VkCommandPoolTrimFlagsKHR flags) {
MVKCommandPool* mvkCmdPool = (MVKCommandPool*)commandPool; MVKCommandPool* mvkCmdPool = (MVKCommandPool*)commandPool;
mvkCmdPool->trim(); mvkCmdPool->trim();
} }
@ -1660,6 +1659,7 @@ MVK_PUBLIC_SYMBOL void vkGetDescriptorSetLayoutSupportKHR(
VkDevice device, VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupportKHR* pSupport) { VkDescriptorSetLayoutSupportKHR* pSupport) {
MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device); MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
mvkDevice->getDescriptorSetLayoutSupport(pCreateInfo, pSupport); mvkDevice->getDescriptorSetLayoutSupport(pCreateInfo, pSupport);
} }
@ -1736,7 +1736,7 @@ MVK_PUBLIC_SYMBOL VkResult vkAcquireNextImageKHR(
uint32_t* pImageIndex) { uint32_t* pImageIndex) {
MVKSwapchain* mvkSwapchain = (MVKSwapchain*)swapchain; MVKSwapchain* mvkSwapchain = (MVKSwapchain*)swapchain;
return mvkSwapchain->acquireNextImageKHR(timeout, semaphore, fence, pImageIndex); return mvkSwapchain->acquireNextImageKHR(timeout, semaphore, fence, ~0u, pImageIndex);
} }
MVK_PUBLIC_SYMBOL VkResult vkQueuePresentKHR( MVK_PUBLIC_SYMBOL VkResult vkQueuePresentKHR(
@ -1747,6 +1747,48 @@ MVK_PUBLIC_SYMBOL VkResult vkQueuePresentKHR(
return mvkQ->submit(pPresentInfo); return mvkQ->submit(pPresentInfo);
} }
MVK_PUBLIC_SYMBOL VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
return mvkDevice->getDeviceGroupPresentCapabilities(pDeviceGroupPresentCapabilities);
}
MVK_PUBLIC_SYMBOL VkResult vkGetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes) {
MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
MVKSurface* mvkSrfc = (MVKSurface*)surface;
return mvkDevice->getDeviceGroupSurfacePresentModes(mvkSrfc, pModes);
}
MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDevicePresentRectanglesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
VkRect2D* pRects) {
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
MVKSurface* mvkSrfc = (MVKSurface*)surface;
return mvkPD->getPresentRectangles(mvkSrfc, pRectCount, pRects);
}
MVK_PUBLIC_SYMBOL VkResult vkAcquireNextImage2KHR(
VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex) {
MVKSwapchain* mvkSwapchain = (MVKSwapchain*)pAcquireInfo->swapchain;
return mvkSwapchain->acquireNextImageKHR(pAcquireInfo->timeout,
pAcquireInfo->semaphore,
pAcquireInfo->fence,
pAcquireInfo->deviceMask,
pImageIndex);
}
#pragma mark - #pragma mark -
#pragma mark VK_KHR_surface extension #pragma mark VK_KHR_surface extension
@ -1805,6 +1847,31 @@ MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
} }
#pragma mark -
#pragma mark VK_KHR_get_surface_capabilities2 extension
MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
MVKSurface* mvkSrfc = (MVKSurface*)pSurfaceInfo->surface;
return mvkPD->getSurfaceCapabilities(mvkSrfc, &pSurfaceCapabilities->surfaceCapabilities);
}
MVK_PUBLIC_SYMBOL VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormat2KHR* pSurfaceFormats) {
MVKPhysicalDevice* mvkPD = MVKPhysicalDevice::getMVKPhysicalDevice(physicalDevice);
MVKSurface* mvkSrfc = (MVKSurface*)pSurfaceInfo->surface;
return mvkPD->getSurfaceFormats(mvkSrfc, pSurfaceFormatCount, pSurfaceFormats);
}
#pragma mark - #pragma mark -
#pragma mark VK_EXT_host_query_reset extension #pragma mark VK_EXT_host_query_reset extension