mirror of
https://github.com/Yours3lf/rpi-vk-driver.git
synced 2024-12-01 13:24:20 +01:00
683 lines
24 KiB
C
683 lines
24 KiB
C
#include "common.h"
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#devsandqueues-physical-device-enumeration
|
|
* If pPhysicalDevices is NULL, then the number of physical devices available is returned in pPhysicalDeviceCount. Otherwise, pPhysicalDeviceCount must point to a
|
|
* variable set by the user to the number of elements in the pPhysicalDevices array, and on return the variable is overwritten with the number of handles actually
|
|
* written to pPhysicalDevices. If pPhysicalDeviceCount is less than the number of physical devices available, at most pPhysicalDeviceCount structures will be written.
|
|
* If pPhysicalDeviceCount is smaller than the number of physical devices available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the
|
|
* available physical devices were returned.
|
|
*/
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceCount,
|
|
VkPhysicalDevice* pPhysicalDevices)
|
|
{
|
|
assert(instance);
|
|
|
|
int numGPUs = 1;
|
|
|
|
assert(pPhysicalDeviceCount);
|
|
|
|
if(!pPhysicalDevices)
|
|
{
|
|
*pPhysicalDeviceCount = numGPUs;
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
int arraySize = *pPhysicalDeviceCount;
|
|
int elementsWritten = min(numGPUs, arraySize);
|
|
|
|
for(int c = 0; c < elementsWritten; ++c)
|
|
{
|
|
pPhysicalDevices[c] = &instance->dev;
|
|
}
|
|
|
|
*pPhysicalDeviceCount = elementsWritten;
|
|
|
|
if(arraySize < numGPUs)
|
|
{
|
|
return VK_INCOMPLETE;
|
|
}
|
|
else
|
|
{
|
|
return VK_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties
|
|
*/
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties* pProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pProperties);
|
|
|
|
VkPhysicalDeviceSparseProperties sparseProps =
|
|
{
|
|
.residencyStandard2DBlockShape = 1,
|
|
.residencyStandard2DMultisampleBlockShape = 1,
|
|
.residencyStandard3DBlockShape = 1,
|
|
.residencyAlignedMipSize = 1,
|
|
.residencyNonResidentStrict = 1
|
|
};
|
|
|
|
pProperties->apiVersion = VK_DRIVER_VERSION;
|
|
pProperties->driverVersion = 1; //we'll simply call this v1
|
|
pProperties->vendorID = 0x14E4; //Broadcom
|
|
pProperties->deviceID = 0; //TODO dunno?
|
|
pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
|
|
strcpy(pProperties->deviceName, "VideoCore IV HW");
|
|
//pProperties->pipelineCacheUUID
|
|
pProperties->limits = _limits;
|
|
pProperties->sparseProperties = sparseProps;
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures
|
|
*/
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures* pFeatures)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pFeatures);
|
|
|
|
*pFeatures = _features;
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties
|
|
*/
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const char* pLayerName,
|
|
uint32_t* pPropertyCount,
|
|
VkExtensionProperties* pProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(!pLayerName); //layers ignored for now
|
|
assert(pPropertyCount);
|
|
|
|
if(!pProperties)
|
|
{
|
|
*pPropertyCount = numDeviceExtensions;
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
int arraySize = *pPropertyCount;
|
|
int elementsWritten = min(numDeviceExtensions, arraySize);
|
|
|
|
for(int c = 0; c < elementsWritten; ++c)
|
|
{
|
|
pProperties[c] = deviceExtensions[c];
|
|
}
|
|
|
|
*pPropertyCount = elementsWritten;
|
|
|
|
if(arraySize < numDeviceExtensions)
|
|
{
|
|
return VK_INCOMPLETE;
|
|
}
|
|
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties
|
|
* If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount.
|
|
* Otherwise, pQueueFamilyPropertyCount must point to a variable set by the user to the number of elements in the pQueueFamilyProperties array,
|
|
* and on return the variable is overwritten with the number of structures actually written to pQueueFamilyProperties. If pQueueFamilyPropertyCount
|
|
* is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written.
|
|
*/
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties* pQueueFamilyProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pQueueFamilyPropertyCount);
|
|
|
|
if(!pQueueFamilyProperties)
|
|
{
|
|
*pQueueFamilyPropertyCount = 1;
|
|
return;
|
|
}
|
|
|
|
int arraySize = *pQueueFamilyPropertyCount;
|
|
int elementsWritten = min(numQueueFamilies, arraySize);
|
|
|
|
for(int c = 0; c < elementsWritten; ++c)
|
|
{
|
|
pQueueFamilyProperties[c] = _queueFamilyProperties[c];
|
|
}
|
|
|
|
*pQueueFamilyPropertyCount = elementsWritten;
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDevice
|
|
* vkCreateDevice verifies that extensions and features requested in the ppEnabledExtensionNames and pEnabledFeatures
|
|
* members of pCreateInfo, respectively, are supported by the implementation. If any requested extension is not supported,
|
|
* vkCreateDevice must return VK_ERROR_EXTENSION_NOT_PRESENT. If any requested feature is not supported, vkCreateDevice must return
|
|
* VK_ERROR_FEATURE_NOT_PRESENT. Support for extensions can be checked before creating a device by querying vkEnumerateDeviceExtensionProperties
|
|
* After verifying and enabling the extensions the VkDevice object is created and returned to the application.
|
|
* If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance
|
|
* time for the creation to succeed. Multiple logical devices can be created from the same physical device. Logical device creation may
|
|
* fail due to lack of device-specific resources (in addition to the other errors). If that occurs, vkCreateDevice will return VK_ERROR_TOO_MANY_OBJECTS.
|
|
*/
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDeviceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDevice* pDevice)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pDevice);
|
|
assert(pCreateInfo);
|
|
|
|
//check for enabled extensions
|
|
for(int c = 0; c < pCreateInfo->enabledExtensionCount; ++c)
|
|
{
|
|
int findres = findDeviceExtension(pCreateInfo->ppEnabledExtensionNames[c]);
|
|
if(findres == -1)
|
|
{
|
|
return VK_ERROR_EXTENSION_NOT_PRESENT;
|
|
}
|
|
}
|
|
|
|
//check for enabled features
|
|
VkBool32* requestedFeatures = pCreateInfo->pEnabledFeatures;
|
|
VkBool32* supportedFeatures = &_features;
|
|
|
|
if(requestedFeatures)
|
|
{
|
|
for(int c = 0; c < numFeatures; ++c)
|
|
{
|
|
if(requestedFeatures[c] && !supportedFeatures[c])
|
|
{
|
|
return VK_ERROR_FEATURE_NOT_PRESENT;
|
|
}
|
|
}
|
|
}
|
|
|
|
*pDevice = ALLOCATE(sizeof(_device), 1, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
|
|
if(!*pDevice)
|
|
{
|
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
|
}
|
|
|
|
(*pDevice)->dev = physicalDevice;
|
|
|
|
(*pDevice)->numEnabledExtensions = 0;
|
|
|
|
for(int c = 0; c < pCreateInfo->enabledExtensionCount; ++c)
|
|
{
|
|
int findres = findDeviceExtension(pCreateInfo->ppEnabledExtensionNames[c]);
|
|
if(findres > -1)
|
|
{
|
|
(*pDevice)->enabledExtensions[(*pDevice)->numEnabledExtensions] = findres;
|
|
(*pDevice)->numEnabledExtensions++;
|
|
}
|
|
}
|
|
|
|
if(requestedFeatures)
|
|
{
|
|
for(int c = 0; c < numFeatures; ++c)
|
|
{
|
|
if(requestedFeatures[c] && !supportedFeatures[c])
|
|
{
|
|
return VK_ERROR_FEATURE_NOT_PRESENT;
|
|
}
|
|
}
|
|
|
|
(*pDevice)->enabledFeatures = *pCreateInfo->pEnabledFeatures;
|
|
}
|
|
else
|
|
{
|
|
memset(&(*pDevice)->enabledFeatures, 0, sizeof((*pDevice)->enabledFeatures)); //just disable everything
|
|
}
|
|
|
|
//layers ignored per spec
|
|
//pCreateInfo->enabledLayerCount
|
|
|
|
for(int c = 0; c < numQueueFamilies; ++c)
|
|
{
|
|
(*pDevice)->queues[c] = 0;
|
|
}
|
|
|
|
if(pCreateInfo->queueCreateInfoCount > 0)
|
|
{
|
|
for(int c = 0; c < pCreateInfo->queueCreateInfoCount; ++c)
|
|
{
|
|
(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex] = ALLOCATE(sizeof(_queue)*pCreateInfo->pQueueCreateInfos[c].queueCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
|
|
|
|
if(!(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex])
|
|
{
|
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
|
}
|
|
|
|
for(int d = 0; d < pCreateInfo->pQueueCreateInfos[c].queueCount; ++d)
|
|
{
|
|
(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex][d].lastEmitSeqno = 0;
|
|
}
|
|
|
|
(*pDevice)->numQueues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex] = pCreateInfo->pQueueCreateInfos[c].queueCount;
|
|
}
|
|
}
|
|
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceQueue
|
|
* vkGetDeviceQueue must only be used to get queues that were created with the flags parameter of VkDeviceQueueCreateInfo set to zero.
|
|
* To get queues that were created with a non-zero flags parameter use vkGetDeviceQueue2.
|
|
*/
|
|
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
|
|
VkDevice device,
|
|
uint32_t queueFamilyIndex,
|
|
uint32_t queueIndex,
|
|
VkQueue* pQueue)
|
|
{
|
|
assert(device);
|
|
assert(pQueue);
|
|
|
|
assert(queueFamilyIndex < numQueueFamilies);
|
|
assert(queueIndex < device->numQueues[queueFamilyIndex]);
|
|
|
|
*pQueue = &device->queues[queueFamilyIndex][queueIndex];
|
|
(*pQueue)->dev = device;
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
|
|
VkDevice device,
|
|
const VkDeviceQueueInfo2* pQueueInfo,
|
|
VkQueue* pQueue)
|
|
{
|
|
assert(device);
|
|
assert(pQueueInfo);
|
|
assert(pQueue);
|
|
|
|
vkGetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDevice
|
|
* To ensure that no work is active on the device, vkDeviceWaitIdle can be used to gate the destruction of the device.
|
|
* Prior to destroying a device, an application is responsible for destroying/freeing any Vulkan objects that were created using that device as the
|
|
* first parameter of the corresponding vkCreate* or vkAllocate* command
|
|
*/
|
|
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
|
|
VkDevice device,
|
|
const VkAllocationCallbacks* pAllocator)
|
|
{
|
|
_device* dev = device;
|
|
|
|
if(dev)
|
|
{
|
|
for(int c = 0; c < numQueueFamilies; ++c)
|
|
{
|
|
for(int d = 0; d < dev->numQueues[c]; ++d)
|
|
{
|
|
FREE(dev->queues[d]);
|
|
}
|
|
}
|
|
FREE(dev);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups
|
|
*/
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceGroupCount,
|
|
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
|
|
{
|
|
assert(instance);
|
|
assert(pPhysicalDeviceGroupCount);
|
|
|
|
if(!pPhysicalDeviceGroupProperties)
|
|
{
|
|
*pPhysicalDeviceGroupCount = 1;
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
//TODO
|
|
uint32_t c = 0;
|
|
for(; c < *pPhysicalDeviceGroupCount; ++c)
|
|
{
|
|
pPhysicalDeviceGroupProperties[c].physicalDeviceCount = 1;
|
|
pPhysicalDeviceGroupProperties[c].physicalDevices[0] = &instance->dev;
|
|
pPhysicalDeviceGroupProperties[c].subsetAllocation = 0;
|
|
}
|
|
|
|
if(c < 1)
|
|
{
|
|
return VK_INCOMPLETE;
|
|
}
|
|
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
|
|
VkDevice device,
|
|
const char* pName)
|
|
{
|
|
if(
|
|
!strcmp("vkDestroyInstance", pName) ||
|
|
!strcmp("vkEnumeratePhysicalDevices", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceFeatures", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceFormatProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceImageFormatProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceQueueFamilyProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceMemoryProperties", pName) ||
|
|
!strcmp("vkCreateDevice", pName) ||
|
|
!strcmp("vkEnumerateDeviceExtensionProperties", pName) ||
|
|
!strcmp("vkEnumerateDeviceLayerProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties", pName) ||
|
|
!strcmp("vkEnumeratePhysicalDeviceGroups", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceFeatures2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceFormatProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceImageFormatProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceQueueFamilyProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceMemoryProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties2", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceExternalBufferProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceExternalFenceProperties", pName) ||
|
|
!strcmp("vkGetPhysicalDeviceExternalSemaphoreProperties", pName)
|
|
)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
//TODO
|
|
_device* d = device;
|
|
return vkGetInstanceProcAddr(d->dev->instance, pName);
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties2* pProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pProperties);
|
|
vkGetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
|
|
|
|
if(pProperties->pNext)
|
|
{
|
|
VkPhysicalDeviceDriverPropertiesKHR* ptr = pProperties->pNext;
|
|
if(ptr->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR)
|
|
{
|
|
//TODO apparently can't expose my own ID :(
|
|
//has to be "known"
|
|
ptr->driverID = VK_DRIVER_ID_MESA_RADV_KHR;
|
|
const char* driverName = "RPi VK";
|
|
const char* driverInfo = ""; //TODO maybe version number, git info?
|
|
strcpy(ptr->driverName, driverName);
|
|
strcpy(ptr->driverInfo, driverInfo);
|
|
//TODO this is what we are aspiring to pass...
|
|
ptr->conformanceVersion.major = 1;
|
|
ptr->conformanceVersion.minor = 1;
|
|
ptr->conformanceVersion.subminor = 2;
|
|
ptr->conformanceVersion.patch = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties* pFormatProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pFormatProperties);
|
|
|
|
if(isDepthStencilFormat(format) && format != VK_FORMAT_S8_UINT)
|
|
{
|
|
pFormatProperties->linearTilingFeatures = 0
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_DST_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
pFormatProperties->optimalTilingFeatures = 0
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_DST_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
pFormatProperties->bufferFeatures = 0
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
}
|
|
else
|
|
{
|
|
pFormatProperties->linearTilingFeatures = 0
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
|
|
| VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_DST_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
pFormatProperties->optimalTilingFeatures = 0
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
|
|
| VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
|
|
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
|
| VK_FORMAT_FEATURE_BLIT_DST_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
pFormatProperties->bufferFeatures = 0
|
|
| VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
| VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
|
| VK_FORMAT_FEATURE_TRANSFER_DST_BIT
|
|
;
|
|
}
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties2* pFormatProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pFormatProperties);
|
|
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
|
|
}
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkImageTiling tiling,
|
|
VkImageUsageFlags usage,
|
|
VkImageCreateFlags flags,
|
|
VkImageFormatProperties* pImageFormatProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pImageFormatProperties);
|
|
|
|
VkFormat ycbcrConversionRequiredFormats[] =
|
|
{
|
|
VK_FORMAT_G8B8G8R8_422_UNORM
|
|
,VK_FORMAT_B8G8R8G8_422_UNORM
|
|
,VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
|
|
,VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
|
|
,VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM
|
|
,VK_FORMAT_G8_B8R8_2PLANE_422_UNORM
|
|
,VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM
|
|
,VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
|
|
,VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16
|
|
,VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16
|
|
,VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16
|
|
,VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
|
|
,VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16
|
|
,VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16
|
|
,VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16
|
|
,VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16
|
|
,VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16
|
|
,VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16
|
|
,VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16
|
|
,VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16
|
|
,VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16
|
|
,VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16
|
|
,VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16
|
|
,VK_FORMAT_G16B16G16R16_422_UNORM
|
|
,VK_FORMAT_B16G16R16G16_422_UNORM
|
|
,VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM
|
|
,VK_FORMAT_G16_B16R16_2PLANE_420_UNORM
|
|
,VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM
|
|
,VK_FORMAT_G16_B16R16_2PLANE_422_UNORM
|
|
,VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
|
|
};
|
|
#define numYcbcrConversionRequiredFormats (sizeof(ycbcrConversionRequiredFormats)/sizeof(VkFormat))
|
|
|
|
for(uint32_t c = 0; c < numUnsupportedFormats; ++c)
|
|
{
|
|
if(format == unsupportedFormats[c])
|
|
{
|
|
return VK_ERROR_FORMAT_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
|
|
pImageFormatProperties->maxArrayLayers = _limits.maxImageArrayLayers;
|
|
|
|
pImageFormatProperties->maxExtent.width = 1;
|
|
pImageFormatProperties->maxExtent.height = 1;
|
|
pImageFormatProperties->maxExtent.depth = 1;
|
|
|
|
pImageFormatProperties->sampleCounts = _limits.framebufferColorSampleCounts;
|
|
|
|
if(type == VK_IMAGE_TYPE_1D)
|
|
{
|
|
pImageFormatProperties->maxExtent.width = _limits.maxImageDimension1D;
|
|
pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension1D) + 1;
|
|
}
|
|
else if(type == VK_IMAGE_TYPE_2D)
|
|
{
|
|
pImageFormatProperties->maxExtent.width = _limits.maxImageDimension2D;
|
|
pImageFormatProperties->maxExtent.height = _limits.maxImageDimension2D;
|
|
pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension2D) + 1;
|
|
}
|
|
else
|
|
{
|
|
pImageFormatProperties->maxExtent.width = _limits.maxImageDimension3D;
|
|
pImageFormatProperties->maxExtent.height = _limits.maxImageDimension3D;
|
|
pImageFormatProperties->maxExtent.depth = _limits.maxImageDimension3D;
|
|
pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension3D) + 1;
|
|
}
|
|
|
|
int ycbcrConversionRequired = 0;
|
|
|
|
for(uint32_t c = 0; c < numYcbcrConversionRequiredFormats; ++c)
|
|
{
|
|
if(format == ycbcrConversionRequiredFormats[c])
|
|
{
|
|
ycbcrConversionRequired = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ycbcrConversionRequired ||
|
|
tiling == VK_IMAGE_TILING_LINEAR ||
|
|
type != VK_IMAGE_TYPE_2D ||
|
|
flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT ||
|
|
flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT
|
|
)
|
|
{
|
|
pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
|
|
}
|
|
|
|
//TODO real max size?
|
|
//2^31
|
|
pImageFormatProperties->maxResourceSize = 1<<31;
|
|
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
|
|
VkImageFormatProperties2* pImageFormatProperties)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pImageFormatProperties);
|
|
assert(pImageFormatInfo);
|
|
|
|
//TODO
|
|
|
|
return vkGetPhysicalDeviceImageFormatProperties(physicalDevice,
|
|
pImageFormatInfo->format,
|
|
pImageFormatInfo->type,
|
|
pImageFormatInfo->tiling,
|
|
pImageFormatInfo->usage,
|
|
pImageFormatInfo->flags,
|
|
&pImageFormatProperties->imageFormatProperties);
|
|
}
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkLayerProperties* pProperties)
|
|
{
|
|
//deprecated, just return instance layers
|
|
return vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures2* pFeatures)
|
|
{
|
|
assert(physicalDevice);
|
|
assert(pFeatures);
|
|
vkGetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
|
|
}
|
|
|
|
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties2* pQueueFamilyProperties)
|
|
{
|
|
|
|
}
|