Merge pull request #532 from billhollings/master

Add correct function entry point handling.

Docs/MoltenVK_Runtime_UserGuide.md

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

Docs/Whats_New.md

@@ -19,7 +19,11 @@ MoltenVK 1.0.34
 Released TBD
 
 - 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.
 - Increase shader float constant accuracy beyond 6 digits of precision.
 - MoltenVKShaderConverterTool support cs & csh for compute shader file extensions.

MoltenVK/MoltenVK/GPUObjects/MVKDevice.h

@@ -132,8 +132,7 @@ public:
 	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
 	 * pixel formats supported by the surface.
@@ -148,8 +147,22 @@ public:
 	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
 	 * presentation modes supported by the surface.
@@ -163,36 +176,52 @@ public:
 	 */
 	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
 
 	/**
-	 * 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.
 	 *
-	 * 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.
 	 *
 	 * 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
 	 * 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.
 	 *
-	 * 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.
 	 *
 	 * 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
 	 * an error occurs.
 	 */
-	VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties2KHR* properties);
+	VkResult getQueueFamilyProperties(uint32_t* pCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
 
 	/** Returns a pointer to the Vulkan instance. */
 	inline MVKInstance* getInstance() { return _mvkInstance; }
@@ -338,6 +367,12 @@ public:
 	void getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
 									   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
 

MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm

@@ -470,7 +470,7 @@ VkResult MVKPhysicalDevice::getSurfaceFormats(MVKSurface* surface,
 	}
 
 	// 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);
 
 	// Now populate the supplied array
@@ -482,6 +482,27 @@ VkResult MVKPhysicalDevice::getSurfaceFormats(MVKSurface* surface,
 	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,
 												   uint32_t* pCount,
 												   VkPresentModeKHR* pPresentModes) {
@@ -512,6 +533,29 @@ VkResult MVKPhysicalDevice::getSurfacePresentModes(MVKSurface* surface,
 	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
 
@@ -552,54 +596,50 @@ vector<MVKQueueFamily*>& MVKPhysicalDevice::getQueueFamilies() {
 }
 
 VkResult MVKPhysicalDevice::getQueueFamilyProperties(uint32_t* pCount,
-													 VkQueueFamilyProperties* queueProperties) {
+													 VkQueueFamilyProperties* pQueueFamilyProperties) {
 
 	vector<MVKQueueFamily*> qFams = getQueueFamilies();
 	uint32_t qfCnt = uint32_t(qFams.size());
 
 	// If properties aren't actually being requested yet, simply update the returned count
-	if ( !queueProperties ) {
+	if ( !pQueueFamilyProperties ) {
 		*pCount = qfCnt;
 		return VK_SUCCESS;
 	}
 
 	// Determine how many families we'll return, and return that number
+	VkResult rslt = (*pCount >= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE;
 	*pCount = min(*pCount, qfCnt);
 
 	// Now populate the queue families
-	if (queueProperties) {
+	if (pQueueFamilyProperties) {
 		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,
-													 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;
-	// Determine how many families we'll return, and return that number
+			pQP->pNext = nullptr;
-	*pCount = min(*pCount, qfCnt);
+			pQP->queueFamilyProperties = qProps[qpIdx];
-
-	// 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);
 		}
+	} else {
+		rslt = getQueueFamilyProperties(pCount, (VkQueueFamilyProperties*)nullptr);
 	}
-
+	return rslt;
-	return (*pCount <= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE;
 }
 
 
@@ -1509,8 +1549,15 @@ MVKPhysicalDevice::~MVKPhysicalDevice() {
 #pragma mark -
 #pragma mark MVKDevice
 
+// Returns core device commands and enabled extension device commands.
 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) {
@@ -1539,6 +1586,20 @@ void MVKDevice::getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateI
 	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
 

MoltenVK/MoltenVK/GPUObjects/MVKInstance.h

@@ -27,6 +27,21 @@
 #include <string>
 
 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 -
@@ -37,8 +52,8 @@ class MVKInstance : public MVKDispatchableObject {
 
 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 
@@ -97,7 +112,10 @@ public:
     }
 
 protected:
+	friend MVKDevice;
+
 	void initProcAddrs();
+	MVKEntryPoint* getEntryPoint(const char* pName);
 	void initConfig();
     void logVersions();
 	VkResult verifyLayers(uint32_t count, const char* const* names);
@@ -105,6 +123,6 @@ protected:
 	MVKConfiguration _mvkConfig;
 	VkApplicationInfo _appInfo;
 	std::vector<MVKPhysicalDevice*> _physicalDevices;
-	std::unordered_map<std::string, PFN_vkVoidFunction> _procAddrMap;
+	std::unordered_map<std::string, MVKEntryPoint> _entryPoints;
 };
 

MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm

@@ -30,6 +30,22 @@ using namespace std;
 #pragma mark -
 #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) {
 
 	// 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
-	VkResult result = (*pCount <= pdCnt) ? VK_SUCCESS : VK_INCOMPLETE;
+	VkResult result = (*pCount >= pdCnt) ? VK_SUCCESS : VK_INCOMPLETE;
 	*pCount = min(pdCnt, *pCount);
 
 	// Now populate the devices
@@ -152,199 +168,217 @@ MVKInstance::MVKInstance(const VkInstanceCreateInfo* pCreateInfo) {
 	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. */
 void MVKInstance::initProcAddrs() {
 
 	// 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:
-	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
-	ADD_PROC_ADDR(vkCreateIOSSurfaceMVK);
+	ADD_INST_EXT_ENTRY_POINT(vkCreateIOSSurfaceMVK, MVK_IOS_SURFACE);
 #endif
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-	ADD_PROC_ADDR(vkCreateMacOSSurfaceMVK);
+	ADD_INST_EXT_ENTRY_POINT(vkCreateMacOSSurfaceMVK, MVK_MACOS_SURFACE);
 #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() {

MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.h

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

MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm

@@ -49,7 +49,7 @@ VkResult MVKSwapchain::getImages(uint32_t* pCount, VkImage* pSwapchainImages) {
 	}
 
 	// 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);
 
 	// Now populate the images
@@ -63,6 +63,7 @@ VkResult MVKSwapchain::getImages(uint32_t* pCount, VkImage* pSwapchainImages) {
 VkResult MVKSwapchain::acquireNextImageKHR(uint64_t timeout,
                                            VkSemaphore semaphore,
                                            VkFence fence,
+										   uint32_t deviceMask,
                                            uint32_t* pImageIndex) {
     // Find the image that has the smallest availability measure
     uint32_t minWaitIndex = 0;

MoltenVK/MoltenVK/Layers/MVKExtensions.cpp

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

MoltenVK/MoltenVK/Layers/MVKExtensions.def

@@ -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_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_surface_capabilities2, KHR_GET_SURFACE_CAPABILITIES_2)
 MVK_EXTENSION(KHR_image_format_list, KHR_IMAGE_FORMAT_LIST)
 MVK_EXTENSION(KHR_maintenance1, KHR_MAINTENANCE1)
 MVK_EXTENSION(KHR_maintenance2, KHR_MAINTENANCE2)

MoltenVK/MoltenVK/Layers/MVKLayers.mm

@@ -100,7 +100,7 @@ VkResult MVKLayerManager::getLayerProperties(uint32_t* pCount, VkLayerProperties
 
 	// Othewise, determine how many layers we'll return, and return that count
 	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);
 
 	// Now populate the layer properties

MoltenVK/MoltenVK/Vulkan/vulkan.mm

@@ -132,16 +132,14 @@ MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetInstanceProcAddr(
     VkInstance                                  instance,
     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, "vkEnumerateInstanceExtensionProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; }
 	if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; }
-    if (instance) {
+	if ( !instance ) { return nullptr; }
-        MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
+
-        return mvkInst->getProcAddr(pName);
+	MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
-    }
+	return mvkInst->getProcAddr(pName);
-    return NULL;
 }
 
 MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetDeviceProcAddr(
@@ -1648,6 +1646,7 @@ MVK_PUBLIC_SYMBOL void vkTrimCommandPoolKHR(
     VkDevice                                    device,
     VkCommandPool                               commandPool,
     VkCommandPoolTrimFlagsKHR                   flags) {
+
 	MVKCommandPool* mvkCmdPool = (MVKCommandPool*)commandPool;
     mvkCmdPool->trim();
 }
@@ -1660,7 +1659,8 @@ MVK_PUBLIC_SYMBOL void vkGetDescriptorSetLayoutSupportKHR(
     VkDevice                                    device,
     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
     VkDescriptorSetLayoutSupportKHR*            pSupport) {
-    MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
+
+	MVKDevice* mvkDevice = MVKDevice::getMVKDevice(device);
     mvkDevice->getDescriptorSetLayoutSupport(pCreateInfo, pSupport);
 }
 
@@ -1736,7 +1736,7 @@ MVK_PUBLIC_SYMBOL VkResult vkAcquireNextImageKHR(
     uint32_t*                                    pImageIndex) {
 
     MVKSwapchain* mvkSwapchain = (MVKSwapchain*)swapchain;
-    return mvkSwapchain->acquireNextImageKHR(timeout, semaphore, fence, pImageIndex);
+    return mvkSwapchain->acquireNextImageKHR(timeout, semaphore, fence, ~0u, pImageIndex);
 }
 
 MVK_PUBLIC_SYMBOL VkResult vkQueuePresentKHR(
@@ -1747,6 +1747,48 @@ MVK_PUBLIC_SYMBOL VkResult vkQueuePresentKHR(
     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 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 VK_EXT_host_query_reset extension