Merge pull request #532 from billhollings/master
Add correct function entry point handling.
This commit is contained in:
Bill Hollings
GitHub
commit
9a14df85af
@ -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`
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -132,8 +132,7 @@ public:
|
||||
VkResult getSurfaceCapabilities(MVKSurface* surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
|
||||
|
||||
/**
|
||||
* Returns the pixel formats supported by the surface described by the specified
|
||||
* surface description.
|
||||
* Returns the pixel formats supported by the surface.
|
||||
*
|
||||
* 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
|
||||
* surface description.
|
||||
* Returns the pixel formats supported by the surface.
|
||||
*
|
||||
* 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
|
||||
* array. If the number of available queue families is less than pCount, the value of
|
||||
* If pQueueFamilyProperties is not null, then pCount queue family properties are copied into
|
||||
* 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
|
||||
* array. If the number of available queue families is less than pCount, the value of
|
||||
* If pQueueFamilyProperties is not null, then pCount queue family properties are copied into
|
||||
* 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
|
||||
|
||||
|
||||
@ -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();
|
||||
uint32_t qfCnt = uint32_t(qFams.size());
|
||||
|
||||
// If properties aren't actually being requested yet, simply update the returned count
|
||||
if ( !queueProperties ) {
|
||||
*pCount = qfCnt;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
// Determine how many families we'll return, and return that number
|
||||
*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);
|
||||
VkResult rslt;
|
||||
if (pQueueFamilyProperties) {
|
||||
// Populate temp array of VkQueueFamilyProperties then copy into array of VkQueueFamilyProperties2KHR.
|
||||
// The value of *pCount may be reduced during call, but will always be <= size of temp array.
|
||||
VkQueueFamilyProperties qProps[*pCount];
|
||||
rslt = getQueueFamilyProperties(pCount, qProps);
|
||||
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 {
|
||||
rslt = getQueueFamilyProperties(pCount, (VkQueueFamilyProperties*)nullptr);
|
||||
}
|
||||
|
||||
return (*pCount <= qfCnt) ? VK_SUCCESS : VK_INCOMPLETE;
|
||||
return rslt;
|
||||
}
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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. */
|
||||
inline PFN_vkVoidFunction getProcAddr(const char* pName) { return _procAddrMap[pName]; }
|
||||
/** Returns the function pointer corresponding to the named entry point, or NULL if it doesn't exist. */
|
||||
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;
|
||||
};
|
||||
|
||||
|
||||
@ -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_PROC_ADDR(vkEnumeratePhysicalDevices);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceFeatures);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceFormatProperties);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceImageFormatProperties);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceProperties);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceQueueFamilyProperties);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceMemoryProperties);
|
||||
ADD_PROC_ADDR(vkGetInstanceProcAddr);
|
||||
ADD_PROC_ADDR(vkGetDeviceProcAddr);
|
||||
ADD_PROC_ADDR(vkCreateDevice);
|
||||
ADD_PROC_ADDR(vkEnumerateDeviceExtensionProperties);
|
||||
ADD_PROC_ADDR(vkEnumerateDeviceLayerProperties);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceSparseImageFormatProperties);
|
||||
ADD_INST_ENTRY_POINT(vkDestroyInstance);
|
||||
ADD_INST_ENTRY_POINT(vkEnumeratePhysicalDevices);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceFeatures);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceFormatProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceImageFormatProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceQueueFamilyProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceMemoryProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetInstanceProcAddr);
|
||||
ADD_INST_ENTRY_POINT(vkCreateDevice);
|
||||
ADD_INST_ENTRY_POINT(vkEnumerateDeviceExtensionProperties);
|
||||
ADD_INST_ENTRY_POINT(vkEnumerateDeviceLayerProperties);
|
||||
ADD_INST_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties);
|
||||
|
||||
// Device functions:
|
||||
ADD_PROC_ADDR(vkDestroyDevice);
|
||||
ADD_PROC_ADDR(vkGetDeviceQueue);
|
||||
ADD_PROC_ADDR(vkQueueSubmit);
|
||||
ADD_PROC_ADDR(vkQueueWaitIdle);
|
||||
ADD_PROC_ADDR(vkDeviceWaitIdle);
|
||||
ADD_PROC_ADDR(vkAllocateMemory);
|
||||
ADD_PROC_ADDR(vkFreeMemory);
|
||||
ADD_PROC_ADDR(vkMapMemory);
|
||||
ADD_PROC_ADDR(vkUnmapMemory);
|
||||
ADD_PROC_ADDR(vkFlushMappedMemoryRanges);
|
||||
ADD_PROC_ADDR(vkInvalidateMappedMemoryRanges);
|
||||
ADD_PROC_ADDR(vkGetDeviceMemoryCommitment);
|
||||
ADD_PROC_ADDR(vkBindBufferMemory);
|
||||
ADD_PROC_ADDR(vkBindImageMemory);
|
||||
ADD_PROC_ADDR(vkGetBufferMemoryRequirements);
|
||||
ADD_PROC_ADDR(vkGetImageMemoryRequirements);
|
||||
ADD_PROC_ADDR(vkGetImageSparseMemoryRequirements);
|
||||
ADD_PROC_ADDR(vkQueueBindSparse);
|
||||
ADD_PROC_ADDR(vkCreateFence);
|
||||
ADD_PROC_ADDR(vkDestroyFence);
|
||||
ADD_PROC_ADDR(vkResetFences);
|
||||
ADD_PROC_ADDR(vkGetFenceStatus);
|
||||
ADD_PROC_ADDR(vkWaitForFences);
|
||||
ADD_PROC_ADDR(vkCreateSemaphore);
|
||||
ADD_PROC_ADDR(vkDestroySemaphore);
|
||||
ADD_PROC_ADDR(vkCreateEvent);
|
||||
ADD_PROC_ADDR(vkDestroyEvent);
|
||||
ADD_PROC_ADDR(vkGetEventStatus);
|
||||
ADD_PROC_ADDR(vkSetEvent);
|
||||
ADD_PROC_ADDR(vkResetEvent);
|
||||
ADD_PROC_ADDR(vkCreateQueryPool);
|
||||
ADD_PROC_ADDR(vkDestroyQueryPool);
|
||||
ADD_PROC_ADDR(vkGetQueryPoolResults);
|
||||
ADD_PROC_ADDR(vkCreateBuffer);
|
||||
ADD_PROC_ADDR(vkDestroyBuffer);
|
||||
ADD_PROC_ADDR(vkCreateBufferView);
|
||||
ADD_PROC_ADDR(vkDestroyBufferView);
|
||||
ADD_PROC_ADDR(vkCreateImage);
|
||||
ADD_PROC_ADDR(vkDestroyImage);
|
||||
ADD_PROC_ADDR(vkGetImageSubresourceLayout);
|
||||
ADD_PROC_ADDR(vkCreateImageView);
|
||||
ADD_PROC_ADDR(vkDestroyImageView);
|
||||
ADD_PROC_ADDR(vkCreateShaderModule);
|
||||
ADD_PROC_ADDR(vkDestroyShaderModule);
|
||||
ADD_PROC_ADDR(vkCreatePipelineCache);
|
||||
ADD_PROC_ADDR(vkDestroyPipelineCache);
|
||||
ADD_PROC_ADDR(vkGetPipelineCacheData);
|
||||
ADD_PROC_ADDR(vkMergePipelineCaches);
|
||||
ADD_PROC_ADDR(vkCreateGraphicsPipelines);
|
||||
ADD_PROC_ADDR(vkCreateComputePipelines);
|
||||
ADD_PROC_ADDR(vkDestroyPipeline);
|
||||
ADD_PROC_ADDR(vkCreatePipelineLayout);
|
||||
ADD_PROC_ADDR(vkDestroyPipelineLayout);
|
||||
ADD_PROC_ADDR(vkCreateSampler);
|
||||
ADD_PROC_ADDR(vkDestroySampler);
|
||||
ADD_PROC_ADDR(vkCreateDescriptorSetLayout);
|
||||
ADD_PROC_ADDR(vkDestroyDescriptorSetLayout);
|
||||
ADD_PROC_ADDR(vkCreateDescriptorPool);
|
||||
ADD_PROC_ADDR(vkDestroyDescriptorPool);
|
||||
ADD_PROC_ADDR(vkResetDescriptorPool);
|
||||
ADD_PROC_ADDR(vkAllocateDescriptorSets);
|
||||
ADD_PROC_ADDR(vkFreeDescriptorSets);
|
||||
ADD_PROC_ADDR(vkUpdateDescriptorSets);
|
||||
ADD_PROC_ADDR(vkCreateFramebuffer);
|
||||
ADD_PROC_ADDR(vkDestroyFramebuffer);
|
||||
ADD_PROC_ADDR(vkCreateRenderPass);
|
||||
ADD_PROC_ADDR(vkDestroyRenderPass);
|
||||
ADD_PROC_ADDR(vkGetRenderAreaGranularity);
|
||||
ADD_PROC_ADDR(vkCreateCommandPool);
|
||||
ADD_PROC_ADDR(vkDestroyCommandPool);
|
||||
ADD_PROC_ADDR(vkResetCommandPool);
|
||||
ADD_PROC_ADDR(vkAllocateCommandBuffers);
|
||||
ADD_PROC_ADDR(vkFreeCommandBuffers);
|
||||
ADD_PROC_ADDR(vkBeginCommandBuffer);
|
||||
ADD_PROC_ADDR(vkEndCommandBuffer);
|
||||
ADD_PROC_ADDR(vkResetCommandBuffer);
|
||||
ADD_PROC_ADDR(vkCmdBindPipeline);
|
||||
ADD_PROC_ADDR(vkCmdSetViewport);
|
||||
ADD_PROC_ADDR(vkCmdSetScissor);
|
||||
ADD_PROC_ADDR(vkCmdSetLineWidth);
|
||||
ADD_PROC_ADDR(vkCmdSetDepthBias);
|
||||
ADD_PROC_ADDR(vkCmdSetBlendConstants);
|
||||
ADD_PROC_ADDR(vkCmdSetDepthBounds);
|
||||
ADD_PROC_ADDR(vkCmdSetStencilCompareMask);
|
||||
ADD_PROC_ADDR(vkCmdSetStencilWriteMask);
|
||||
ADD_PROC_ADDR(vkCmdSetStencilReference);
|
||||
ADD_PROC_ADDR(vkCmdBindDescriptorSets);
|
||||
ADD_PROC_ADDR(vkCmdBindIndexBuffer);
|
||||
ADD_PROC_ADDR(vkCmdBindVertexBuffers);
|
||||
ADD_PROC_ADDR(vkCmdDraw);
|
||||
ADD_PROC_ADDR(vkCmdDrawIndexed);
|
||||
ADD_PROC_ADDR(vkCmdDrawIndirect);
|
||||
ADD_PROC_ADDR(vkCmdDrawIndexedIndirect);
|
||||
ADD_PROC_ADDR(vkCmdDispatch);
|
||||
ADD_PROC_ADDR(vkCmdDispatchIndirect);
|
||||
ADD_PROC_ADDR(vkCmdCopyBuffer);
|
||||
ADD_PROC_ADDR(vkCmdCopyImage);
|
||||
ADD_PROC_ADDR(vkCmdBlitImage);
|
||||
ADD_PROC_ADDR(vkCmdCopyBufferToImage);
|
||||
ADD_PROC_ADDR(vkCmdCopyImageToBuffer);
|
||||
ADD_PROC_ADDR(vkCmdUpdateBuffer);
|
||||
ADD_PROC_ADDR(vkCmdFillBuffer);
|
||||
ADD_PROC_ADDR(vkCmdClearColorImage);
|
||||
ADD_PROC_ADDR(vkCmdClearDepthStencilImage);
|
||||
ADD_PROC_ADDR(vkCmdClearAttachments);
|
||||
ADD_PROC_ADDR(vkCmdResolveImage);
|
||||
ADD_PROC_ADDR(vkCmdSetEvent);
|
||||
ADD_PROC_ADDR(vkCmdResetEvent);
|
||||
ADD_PROC_ADDR(vkCmdWaitEvents);
|
||||
ADD_PROC_ADDR(vkCmdPipelineBarrier);
|
||||
ADD_PROC_ADDR(vkCmdBeginQuery);
|
||||
ADD_PROC_ADDR(vkCmdEndQuery);
|
||||
ADD_PROC_ADDR(vkCmdResetQueryPool);
|
||||
ADD_PROC_ADDR(vkCmdWriteTimestamp);
|
||||
ADD_PROC_ADDR(vkCmdCopyQueryPoolResults);
|
||||
ADD_PROC_ADDR(vkCmdPushConstants);
|
||||
ADD_PROC_ADDR(vkCmdBeginRenderPass);
|
||||
ADD_PROC_ADDR(vkCmdNextSubpass);
|
||||
ADD_PROC_ADDR(vkCmdEndRenderPass);
|
||||
ADD_PROC_ADDR(vkCmdExecuteCommands);
|
||||
ADD_DVC_ENTRY_POINT(vkGetDeviceProcAddr);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyDevice);
|
||||
ADD_DVC_ENTRY_POINT(vkGetDeviceQueue);
|
||||
ADD_DVC_ENTRY_POINT(vkQueueSubmit);
|
||||
ADD_DVC_ENTRY_POINT(vkQueueWaitIdle);
|
||||
ADD_DVC_ENTRY_POINT(vkDeviceWaitIdle);
|
||||
ADD_DVC_ENTRY_POINT(vkAllocateMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkFreeMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkMapMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkUnmapMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkFlushMappedMemoryRanges);
|
||||
ADD_DVC_ENTRY_POINT(vkInvalidateMappedMemoryRanges);
|
||||
ADD_DVC_ENTRY_POINT(vkGetDeviceMemoryCommitment);
|
||||
ADD_DVC_ENTRY_POINT(vkBindBufferMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkBindImageMemory);
|
||||
ADD_DVC_ENTRY_POINT(vkGetBufferMemoryRequirements);
|
||||
ADD_DVC_ENTRY_POINT(vkGetImageMemoryRequirements);
|
||||
ADD_DVC_ENTRY_POINT(vkGetImageSparseMemoryRequirements);
|
||||
ADD_DVC_ENTRY_POINT(vkQueueBindSparse);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateFence);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyFence);
|
||||
ADD_DVC_ENTRY_POINT(vkResetFences);
|
||||
ADD_DVC_ENTRY_POINT(vkGetFenceStatus);
|
||||
ADD_DVC_ENTRY_POINT(vkWaitForFences);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateSemaphore);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroySemaphore);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkGetEventStatus);
|
||||
ADD_DVC_ENTRY_POINT(vkSetEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkResetEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateQueryPool);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyQueryPool);
|
||||
ADD_DVC_ENTRY_POINT(vkGetQueryPoolResults);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateBufferView);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyBufferView);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateImage);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyImage);
|
||||
ADD_DVC_ENTRY_POINT(vkGetImageSubresourceLayout);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateImageView);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyImageView);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateShaderModule);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyShaderModule);
|
||||
ADD_DVC_ENTRY_POINT(vkCreatePipelineCache);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyPipelineCache);
|
||||
ADD_DVC_ENTRY_POINT(vkGetPipelineCacheData);
|
||||
ADD_DVC_ENTRY_POINT(vkMergePipelineCaches);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateGraphicsPipelines);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateComputePipelines);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyPipeline);
|
||||
ADD_DVC_ENTRY_POINT(vkCreatePipelineLayout);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyPipelineLayout);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateSampler);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroySampler);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateDescriptorSetLayout);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyDescriptorSetLayout);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateDescriptorPool);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyDescriptorPool);
|
||||
ADD_DVC_ENTRY_POINT(vkResetDescriptorPool);
|
||||
ADD_DVC_ENTRY_POINT(vkAllocateDescriptorSets);
|
||||
ADD_DVC_ENTRY_POINT(vkFreeDescriptorSets);
|
||||
ADD_DVC_ENTRY_POINT(vkUpdateDescriptorSets);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateFramebuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyFramebuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateRenderPass);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyRenderPass);
|
||||
ADD_DVC_ENTRY_POINT(vkGetRenderAreaGranularity);
|
||||
ADD_DVC_ENTRY_POINT(vkCreateCommandPool);
|
||||
ADD_DVC_ENTRY_POINT(vkDestroyCommandPool);
|
||||
ADD_DVC_ENTRY_POINT(vkResetCommandPool);
|
||||
ADD_DVC_ENTRY_POINT(vkAllocateCommandBuffers);
|
||||
ADD_DVC_ENTRY_POINT(vkFreeCommandBuffers);
|
||||
ADD_DVC_ENTRY_POINT(vkBeginCommandBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkEndCommandBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkResetCommandBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBindPipeline);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetViewport);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetScissor);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetLineWidth);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetDepthBias);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetBlendConstants);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetDepthBounds);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetStencilCompareMask);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetStencilWriteMask);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetStencilReference);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBindDescriptorSets);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBindIndexBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBindVertexBuffers);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDraw);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDrawIndexed);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDrawIndirect);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDrawIndexedIndirect);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDispatch);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdDispatchIndirect);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdCopyBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdCopyImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBlitImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdCopyBufferToImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdCopyImageToBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdUpdateBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdFillBuffer);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdClearColorImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdClearDepthStencilImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdClearAttachments);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdResolveImage);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdSetEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdResetEvent);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdWaitEvents);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdPipelineBarrier);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBeginQuery);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdEndQuery);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdResetQueryPool);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdWriteTimestamp);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdCopyQueryPoolResults);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdPushConstants);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdBeginRenderPass);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdNextSubpass);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdEndRenderPass);
|
||||
ADD_DVC_ENTRY_POINT(vkCmdExecuteCommands);
|
||||
|
||||
// Supported extensions:
|
||||
ADD_PROC_ADDR(vkBindBufferMemory2KHR);
|
||||
ADD_PROC_ADDR(vkBindImageMemory2KHR);
|
||||
ADD_PROC_ADDR(vkCreateDescriptorUpdateTemplateKHR);
|
||||
ADD_PROC_ADDR(vkDestroyDescriptorUpdateTemplateKHR);
|
||||
ADD_PROC_ADDR(vkUpdateDescriptorSetWithTemplateKHR);
|
||||
ADD_PROC_ADDR(vkGetBufferMemoryRequirements2KHR);
|
||||
ADD_PROC_ADDR(vkGetImageMemoryRequirements2KHR);
|
||||
ADD_PROC_ADDR(vkGetImageSparseMemoryRequirements2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceFeatures2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceProperties2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceFormatProperties2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceImageFormatProperties2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceQueueFamilyProperties2KHR);
|
||||
ADD_PROC_ADDR(vkGetPhysicalDeviceMemoryProperties2KHR);
|
||||
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);
|
||||
// Instance extension functions:
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceFeatures2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceImageFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceQueueFamilyProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceMemoryProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkDestroySurfaceKHR, KHR_SURFACE);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceSupportKHR, KHR_SURFACE);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, KHR_SURFACE);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormatsKHR, KHR_SURFACE);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfacePresentModesKHR, KHR_SURFACE);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceCapabilities2KHR, KHR_GET_SURFACE_CAPABILITIES_2);
|
||||
ADD_INST_EXT_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormats2KHR, KHR_GET_SURFACE_CAPABILITIES_2);
|
||||
|
||||
#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() {
|
||||
|
||||
@ -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. */
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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++) {
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -132,16 +132,14 @@ MVK_PUBLIC_SYMBOL PFN_vkVoidFunction vkGetInstanceProcAddr(
|
||||
VkInstance instance,
|
||||
const char* pName) {
|
||||
|
||||
// Handle the function that creates an instance specially.
|
||||
// In this case, the instance parameter is ignored and may be NULL.
|
||||
// Handle the special platform functions where the instance parameter 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) {
|
||||
MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
|
||||
return mvkInst->getProcAddr(pName);
|
||||
}
|
||||
return NULL;
|
||||
if ( !instance ) { return nullptr; }
|
||||
|
||||
MVKInstance* mvkInst = MVKInstance::getMVKInstance(instance);
|
||||
return mvkInst->getProcAddr(pName);
|
||||
}
|
||||
|
||||
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
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user