diff --git a/driver/command.c b/driver/command.c index 5514ae0..4747d99 100644 --- a/driver/command.c +++ b/driver/command.c @@ -497,3 +497,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( //TODO flag? } + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ + +} diff --git a/driver/common.c b/driver/common.c index 62ec662..a88ed76 100644 --- a/driver/common.c +++ b/driver/common.c @@ -566,803 +566,6 @@ void clDump(void* cl, uint32_t size) //////////////////////////////////////////////////// //////////////////////////////////////////////////// -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( - VkDevice device, - VkEvent event) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions) -{ - -} - -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 void VKAPI_CALL vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( - VkDevice device, - VkEvent event) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ - -} - -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 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 vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( - VkDevice device, - VkEvent event) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) -{ - assert(physicalDevice); - assert(pFeatures); - vkGetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); -} - -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 vkGetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) -{ - assert(physicalDevice); - assert(pFormatProperties); - vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); -} - -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 void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) -{ - -} - - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) -{ - -} - VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, @@ -1388,14 +591,6 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( } -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) -{ - return VK_SUCCESS; -} - VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, @@ -1405,122 +600,3 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( { } - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - assert(device); - assert(pInfo); - assert(pMemoryRequirements); - - vkGetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); -} - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ - -} - -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); -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) -{ - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) -{ - -} - -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) -{ - -} - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) -{ - return VK_SUCCESS; -} diff --git a/driver/compute.c b/driver/compute.c new file mode 100644 index 0000000..e307c0a --- /dev/null +++ b/driver/compute.c @@ -0,0 +1,43 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ + +} diff --git a/driver/copy.c b/driver/copy.c index e69de29..7cbdf07 100644 --- a/driver/copy.c +++ b/driver/copy.c @@ -0,0 +1,72 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions) +{ + +} diff --git a/driver/descriptorSet.c b/driver/descriptorSet.c index e69de29..f663425 100644 --- a/driver/descriptorSet.c +++ b/driver/descriptorSet.c @@ -0,0 +1,120 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets) +{ + return VK_SUCCESS; +} + + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) +{ + +} diff --git a/driver/device.c b/driver/device.c index 2d31682..18476d6 100644 --- a/driver/device.c +++ b/driver/device.c @@ -157,29 +157,6 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( *pQueueFamilyPropertyCount = elementsWritten; } -/* - * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceSupportKHR - * does this queue family support presentation to this surface? - */ -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) -{ - assert(pSupported); - assert(surface); - assert(physicalDevice); - - assert(queueFamilyIndex < numQueueFamilies); - - //TODO if we plan to support headless rendering, there should be 2 families - //one using /dev/dri/card0 which has modesetting - //other using /dev/dri/renderD128 which does not support modesetting, this would say false here - *pSupported = VK_TRUE; - return VK_SUCCESS; -} - /* * 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 @@ -315,6 +292,18 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( (*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. @@ -412,3 +401,282 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( _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) +{ + +} diff --git a/driver/draw.c b/driver/draw.c index a9ac570..22b5957 100644 --- a/driver/draw.c +++ b/driver/draw.c @@ -262,3 +262,34 @@ void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t ins clInsertUniformXYScale(&commandBuffer->uniformsCl, (float)(i->width) * 0.5f * 16.0f); clInsertUniformZOffset(&commandBuffer->uniformsCl, 0.5f); } + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance) +{ + +} diff --git a/driver/instance.c b/driver/instance.c index bc1a28f..5917bc1 100644 --- a/driver/instance.c +++ b/driver/instance.c @@ -336,3 +336,10 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( return 0; } + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) +{ + return VK_SUCCESS; +} diff --git a/driver/memory.c b/driver/memory.c index 8c9bb63..99aa840 100644 --- a/driver/memory.c +++ b/driver/memory.c @@ -176,3 +176,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( return VK_SUCCESS; } + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes) +{ + +} diff --git a/driver/pipeline.c b/driver/pipeline.c index a2f8f05..93ee842 100644 --- a/driver/pipeline.c +++ b/driver/pipeline.c @@ -196,3 +196,55 @@ void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationC FREE(pip); } } + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) +{ + return VK_SUCCESS; +} diff --git a/driver/query.c b/driver/query.c index e69de29..30c5c6e 100644 --- a/driver/query.c +++ b/driver/query.c @@ -0,0 +1,81 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query) +{ + +} diff --git a/driver/resource.c b/driver/resource.c index 7adc632..8e538b3 100644 --- a/driver/resource.c +++ b/driver/resource.c @@ -71,6 +71,18 @@ void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryReq pMemoryRequirements->memoryTypeBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; //TODO } +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + assert(device); + assert(pInfo); + assert(pMemoryRequirements); + + vkGetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); +} + /* * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBindBufferMemory */ @@ -311,3 +323,47 @@ VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( return VK_SUCCESS; } + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout) +{ + +} diff --git a/driver/sampler.c b/driver/sampler.c new file mode 100644 index 0000000..f9e2fc4 --- /dev/null +++ b/driver/sampler.c @@ -0,0 +1,37 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) +{ + +} diff --git a/driver/sparse.c b/driver/sparse.c new file mode 100644 index 0000000..692c17e --- /dev/null +++ b/driver/sparse.c @@ -0,0 +1,52 @@ +#include "common.h" + +//TODO + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + +} diff --git a/driver/sync.c b/driver/sync.c index a27c7bb..47fdb6a 100644 --- a/driver/sync.c +++ b/driver/sync.c @@ -454,3 +454,73 @@ VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( return VK_SUCCESS; } + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator) +{ + +} + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ + +} + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event) +{ + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ + +} diff --git a/driver/wsi.c b/driver/wsi.c index c057914..1fcfdb7 100644 --- a/driver/wsi.c +++ b/driver/wsi.c @@ -418,3 +418,25 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( FREE(s); } +/* + * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceSupportKHR + * does this queue family support presentation to this surface? + */ +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported) +{ + assert(pSupported); + assert(surface); + assert(physicalDevice); + + assert(queueFamilyIndex < numQueueFamilies); + + //TODO if we plan to support headless rendering, there should be 2 families + //one using /dev/dri/card0 which has modesetting + //other using /dev/dri/renderD128 which does not support modesetting, this would say false here + *pSupported = VK_TRUE; + return VK_SUCCESS; +}