#include "VkCommandPool.hpp"
#include "VkConfig.h"
#include "VkDebug.hpp"
+#include "VkDescriptorPool.hpp"
+#include "VkDescriptorSetLayout.hpp"
+#include "VkDescriptorUpdateTemplate.hpp"
#include "VkDestroy.h"
#include "VkDevice.hpp"
#include "VkDeviceMemory.hpp"
#include "VkShaderModule.hpp"
#include "VkRenderPass.hpp"
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include "WSI/XlibSurfaceKHR.hpp"
+#endif
+
+#include "WSI/VkSwapchainKHR.hpp"
+
#include <algorithm>
#include <cstring>
#include <string>
+namespace
+{
+
+bool HasExtensionProperty(const char* extensionName, const VkExtensionProperties* extensionProperties, uint32_t extensionPropertiesCount)
+{
+ for(uint32_t j = 0; j < extensionPropertiesCount; ++j)
+ {
+ if(strcmp(extensionName, extensionProperties[j].extensionName) == 0)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+}
+
extern "C"
{
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName)
return vk::GetInstanceProcAddr(instance, pName);
}
+VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion)
+{
+ *pSupportedVersion = 3;
+ return VK_SUCCESS;
+}
+
+static const VkExtensionProperties instanceExtensionProperties[] =
+{
+ { VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION },
+ { VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION },
+#ifndef __ANDROID__
+ { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION },
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ { VK_KHR_XLIB_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_SPEC_VERSION },
+#endif
+};
+
+static const VkExtensionProperties deviceExtensionProperties[] =
+{
+ { VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION },
+ { VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, VK_KHR_BIND_MEMORY_2_SPEC_VERSION },
+ { VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION },
+ { VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION },
+ { VK_KHR_DEVICE_GROUP_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, VK_KHR_EXTERNAL_FENCE_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION },
+ { VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION },
+ { VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION },
+ { VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_KHR_MAINTENANCE1_SPEC_VERSION },
+ { VK_KHR_MAINTENANCE2_EXTENSION_NAME, VK_KHR_MAINTENANCE2_SPEC_VERSION },
+ { VK_KHR_MAINTENANCE3_EXTENSION_NAME, VK_KHR_MAINTENANCE3_SPEC_VERSION },
+ { VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION },
+ { VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION },
+ { VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION },
+ { VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION },
+ { VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION },
+ { VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, VK_KHR_VARIABLE_POINTERS_SPEC_VERSION },
+#ifndef __ANDROID__
+ { VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION },
+#endif
+};
+
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
TRACE("(const VkInstanceCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkInstance* pInstance = 0x%X)",
if(pCreateInfo->enabledLayerCount)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->enabledLayerCount");
}
- if(pCreateInfo->enabledExtensionCount)
+ uint32_t extensionPropertiesCount = sizeof(instanceExtensionProperties) / sizeof(instanceExtensionProperties[0]);
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; ++i)
{
- UNIMPLEMENTED();
+ if (!HasExtensionProperty(pCreateInfo->ppEnabledExtensionNames[i], instanceExtensionProperties, extensionPropertiesCount))
+ {
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
+ }
}
if(pCreateInfo->pNext)
// Vulkan structures in this Specification."
break;
default:
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext");
}
}
break;
default:
- UNIMPLEMENTED();
+ UNIMPLEMENTED("tiling");
}
vk::Cast(physicalDevice)->getImageFormatProperties(format, type, tiling, usage, flags, pImageFormatProperties);
if(pCreateInfo->enabledLayerCount)
{
// "The ppEnabledLayerNames and enabledLayerCount members of VkDeviceCreateInfo are deprecated and their values must be ignored by implementations."
- UNIMPLEMENTED(); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
+ UNIMPLEMENTED("pCreateInfo->enabledLayerCount"); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
+ }
+
+ uint32_t extensionPropertiesCount = sizeof(deviceExtensionProperties) / sizeof(deviceExtensionProperties[0]);
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; ++i)
+ {
+ if (!HasExtensionProperty(pCreateInfo->ppEnabledExtensionNames[i], deviceExtensionProperties, extensionPropertiesCount))
+ {
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
+ }
}
const VkBaseInStructure* extensionCreateInfo = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext);
}
}
break;
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ const VkDeviceGroupDeviceCreateInfo* groupDeviceCreateInfo = reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(extensionCreateInfo);
+
+ if((groupDeviceCreateInfo->physicalDeviceCount != 1) ||
+ (groupDeviceCreateInfo->pPhysicalDevices[0] != physicalDevice))
+ {
+ return VK_ERROR_FEATURE_NOT_PRESENT;
+ }
+ }
+ break;
default:
// "the [driver] must skip over, without processing (other than reading the sType and pNext members) any structures in the chain with sType values not defined by [supported extenions]"
- UNIMPLEMENTED(); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
+ UNIMPLEMENTED("extensionCreateInfo->sType"); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
break;
}
{
if(!vk::Cast(physicalDevice)->hasFeatures(*(pCreateInfo->pEnabledFeatures)))
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pEnabledFeatures");
return VK_ERROR_FEATURE_NOT_PRESENT;
}
}
const VkDeviceQueueCreateInfo& queueCreateInfo = pCreateInfo->pQueueCreateInfos[i];
if(queueCreateInfo.pNext || queueCreateInfo.flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("queueCreateInfo.pNext || queueCreateInfo.flags");
}
ASSERT(queueCreateInfo.queueFamilyIndex < queueFamilyPropertyCount);
TRACE("(const char* pLayerName = 0x%X, uint32_t* pPropertyCount = 0x%X, VkExtensionProperties* pProperties = 0x%X)",
pLayerName, pPropertyCount, pProperties);
- static VkExtensionProperties extensionProperties[] =
- {
- { VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION },
- { VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION },
- { VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION },
- { VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION },
- { VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION },
- };
-
- uint32_t extensionPropertiesCount = sizeof(extensionProperties) / sizeof(extensionProperties[0]);
+ uint32_t extensionPropertiesCount = sizeof(instanceExtensionProperties) / sizeof(instanceExtensionProperties[0]);
if(!pProperties)
{
for(uint32_t i = 0; i < std::min(*pPropertyCount, extensionPropertiesCount); i++)
{
- pProperties[i] = extensionProperties[i];
+ pProperties[i] = instanceExtensionProperties[i];
}
return (*pPropertyCount < extensionPropertiesCount) ? VK_INCOMPLETE : VK_SUCCESS;
{
TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const char* pLayerName, uint32_t* pPropertyCount = 0x%X, VkExtensionProperties* pProperties = 0x%X)", physicalDevice, pPropertyCount, pProperties);
- static VkExtensionProperties extensionProperties[] =
- {
- { VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION },
- { VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, VK_KHR_BIND_MEMORY_2_SPEC_VERSION },
- { VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION },
- { VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION },
- { VK_KHR_DEVICE_GROUP_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_SPEC_VERSION },
- { VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, VK_KHR_EXTERNAL_FENCE_SPEC_VERSION },
- { VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION },
- { VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION },
- { VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION },
- { VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_KHR_MAINTENANCE1_SPEC_VERSION },
- { VK_KHR_MAINTENANCE2_EXTENSION_NAME, VK_KHR_MAINTENANCE2_SPEC_VERSION },
- { VK_KHR_MAINTENANCE3_EXTENSION_NAME, VK_KHR_MAINTENANCE3_SPEC_VERSION },
- { VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION },
- { VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION },
- { VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION },
- { VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION },
- { VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION },
- { VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, VK_KHR_VARIABLE_POINTERS_SPEC_VERSION },
- };
-
- uint32_t extensionPropertiesCount = sizeof(extensionProperties) / sizeof(extensionProperties[0]);
+ uint32_t extensionPropertiesCount = sizeof(deviceExtensionProperties) / sizeof(deviceExtensionProperties[0]);
if(!pProperties)
{
for(uint32_t i = 0; i < std::min(*pPropertyCount, extensionPropertiesCount); i++)
{
- pProperties[i] = extensionProperties[i];
+ pProperties[i] = deviceExtensionProperties[i];
}
return (*pPropertyCount < extensionPropertiesCount) ? VK_INCOMPLETE : VK_SUCCESS;
return VK_SUCCESS;
}
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)\r
-{\r
- TRACE("(VkQueue queue = 0x%X)", queue);\r
-\r
- vk::Cast(queue)->waitIdle();\r
-\r
- return VK_SUCCESS;\r
-}\r
-\r
-VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)\r
-{\r
- TRACE("(VkDevice device = 0x%X)", device);\r
-\r
- vk::Cast(device)->waitIdle();\r
-\r
- return VK_SUCCESS;\r
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
+{
+ TRACE("(VkQueue queue = 0x%X)", queue);
+
+ vk::Cast(queue)->waitIdle();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
+{
+ TRACE("(VkDevice device = 0x%X)", device);
+
+ vk::Cast(device)->waitIdle();
+
+ return VK_SUCCESS;
}
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
// includes a handle of the sole buffer or image resource that the memory *can* be bound to."
break;
default:
- UNIMPLEMENTED();
+ UNIMPLEMENTED("allocationInfo->sType");
break;
}
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)",
+ physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+
+ // We do not support sparse images.
+ *pPropertyCount = 0;
}
VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkQueueBindSparse");
return VK_SUCCESS;
}
if(pCreateInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext");
}
return vk::Fence::Create(pAllocator, pCreateInfo, pFence);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::Semaphore::Create(pAllocator, pCreateInfo, pSemaphore);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::Event::Create(pAllocator, pCreateInfo, pEvent);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::QueryPool::Create(pAllocator, pCreateInfo, pQueryPool);
if(pCreateInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext");
}
return vk::Buffer::Create(pAllocator, pCreateInfo, pBuffer);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::BufferView::Create(pAllocator, pCreateInfo, pView);
if(pCreateInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext");
}
- return vk::Image::Create(pAllocator, pCreateInfo, pImage);
+ vk::Image::CreateInfo imageCreateInfo =
+ {
+ pCreateInfo,
+ device
+ };
+
+ return vk::Image::Create(pAllocator, &imageCreateInfo, pImage);
}
VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
TRACE("(VkDevice device = 0x%X, const VkImageViewCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkImageView* pView = 0x%X)",
device, pCreateInfo, pAllocator, pView);
- if(pCreateInfo->pNext || pCreateInfo->flags)
+ if(pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->flags");
+ }
+
+ const VkBaseInStructure* extensionCreateInfo = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext);
+
+ while(extensionCreateInfo)
+ {
+ switch(extensionCreateInfo->sType)
+ {
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR:
+ {
+ const VkImageViewUsageCreateInfo* multiviewCreateInfo = reinterpret_cast<const VkImageViewUsageCreateInfo*>(extensionCreateInfo);
+ ASSERT(!(~vk::Cast(pCreateInfo->image)->getUsage() & multiviewCreateInfo->usage));
+ }
+ break;
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ const VkSamplerYcbcrConversionInfo* ycbcrConversionInfo = reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(extensionCreateInfo);
+ if(ycbcrConversionInfo->conversion != VK_NULL_HANDLE)
+ {
+ ASSERT((pCreateInfo->components.r == VK_COMPONENT_SWIZZLE_IDENTITY) &&
+ (pCreateInfo->components.g == VK_COMPONENT_SWIZZLE_IDENTITY) &&
+ (pCreateInfo->components.b == VK_COMPONENT_SWIZZLE_IDENTITY) &&
+ (pCreateInfo->components.a == VK_COMPONENT_SWIZZLE_IDENTITY));
+ }
+ }
+ break;
+ default:
+ UNIMPLEMENTED("extensionCreateInfo->sType");
+ break;
+ }
+
+ extensionCreateInfo = extensionCreateInfo->pNext;
}
return vk::ImageView::Create(pAllocator, pCreateInfo, pView);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::ShaderModule::Create(pAllocator, pCreateInfo, pShaderModule);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::PipelineCache::Create(pAllocator, pCreateInfo, pPipelineCache);
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkGetPipelineCacheData");
return VK_SUCCESS;
}
VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkMergePipelineCaches");
return VK_SUCCESS;
}
for(uint32_t i = 0; i < createInfoCount; i++)
{
VkResult result = vk::GraphicsPipeline::Create(pAllocator, &pCreateInfos[i], &pPipelines[i]);
- if(result != VK_SUCCESS)
+ if(result == VK_SUCCESS)
+ {
+ static_cast<vk::GraphicsPipeline*>(vk::Cast(pPipelines[i]))->compileShaders(pAllocator, &pCreateInfos[i]);
+ }
+ else
{
// According to the Vulkan spec, section 9.4. Multiple Pipeline Creation
// "When an application attempts to create many pipelines in a single command,
pPipelines[i] = VK_NULL_HANDLE;
errorResult = result;
}
- else
- {
- static_cast<vk::GraphicsPipeline*>(vk::Cast(pPipelines[i]))->compileShaders(pAllocator, &pCreateInfos[i]);
- }
}
return errorResult;
for(uint32_t i = 0; i < createInfoCount; i++)
{
VkResult result = vk::ComputePipeline::Create(pAllocator, &pCreateInfos[i], &pPipelines[i]);
- if(result != VK_SUCCESS)
+ if(result == VK_SUCCESS)
+ {
+ static_cast<vk::ComputePipeline*>(vk::Cast(pPipelines[i]))->compileShaders(pAllocator, &pCreateInfos[i]);
+ }
+ else
{
// According to the Vulkan spec, section 9.4. Multiple Pipeline Creation
// "When an application attempts to create many pipelines in a single command,
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::PipelineLayout::Create(pAllocator, pCreateInfo, pPipelineLayout);
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::Sampler::Create(pAllocator, pCreateInfo, pSampler);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, const VkDescriptorSetLayoutCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkDescriptorSetLayout* pSetLayout = 0x%X)",
+ device, pCreateInfo, pAllocator, pSetLayout);
+
+ if(pCreateInfo->pNext)
+ {
+ UNIMPLEMENTED("pCreateInfo->pNext");
+ }
+
+ return vk::DescriptorSetLayout::Create(pAllocator, pCreateInfo, pSetLayout);
}
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkDescriptorSetLayout descriptorSetLayout = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, descriptorSetLayout, pAllocator);
+
+ vk::destroy(descriptorSetLayout, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, const VkDescriptorPoolCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkDescriptorPool* pDescriptorPool = 0x%X)",
+ device, pCreateInfo, pAllocator, pDescriptorPool);
+
+ if(pCreateInfo->pNext)
+ {
+ UNIMPLEMENTED("pCreateInfo->pNext");
+ }
+
+ return vk::DescriptorPool::Create(pAllocator, pCreateInfo, pDescriptorPool);
}
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkDescriptorPool descriptorPool = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, descriptorPool, pAllocator);
+
+ vk::destroy(descriptorPool, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, VkDescriptorPool descriptorPool = 0x%X, VkDescriptorPoolResetFlags flags = 0x%X)",
+ device, descriptorPool, flags);
+
+ if(flags)
+ {
+ UNIMPLEMENTED("flags");
+ }
+
+ return vk::Cast(descriptorPool)->reset();
}
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, const VkDescriptorSetAllocateInfo* pAllocateInfo = 0x%X, VkDescriptorSet* pDescriptorSets = 0x%X)",
+ device, pAllocateInfo, pDescriptorSets);
+
+ if(pAllocateInfo->pNext)
+ {
+ UNIMPLEMENTED("pAllocateInfo->pNext");
+ }
+
+ return vk::Cast(pAllocateInfo->descriptorPool)->allocateSets(
+ pAllocateInfo->descriptorSetCount, pAllocateInfo->pSetLayouts, pDescriptorSets);
}
VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkDescriptorPool descriptorPool = 0x%X, uint32_t descriptorSetCount = %d, const VkDescriptorSet* pDescriptorSets = 0x%X)",
+ device, descriptorPool, descriptorSetCount, pDescriptorSets);
+
+ vk::Cast(descriptorPool)->freeSets(descriptorSetCount, pDescriptorSets);
+
return VK_SUCCESS;
}
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, uint32_t descriptorWriteCount = %d, const VkWriteDescriptorSet* pDescriptorWrites = 0x%X, uint32_t descriptorCopyCount = %d, const VkCopyDescriptorSet* pDescriptorCopies = 0x%X)",
+ device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+
+ vk::Cast(device)->updateDescriptorSets(descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
if(pCreateInfo->pNext || pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags");
}
return vk::Framebuffer::Create(pAllocator, pCreateInfo, pFramebuffer);
TRACE("(VkDevice device = 0x%X, const VkRenderPassCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkRenderPass* pRenderPass = 0x%X)",
device, pCreateInfo, pAllocator, pRenderPass);
- if(pCreateInfo->pNext || pCreateInfo->flags)
+ if(pCreateInfo->flags)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->flags");
+ }
+
+ const VkBaseInStructure* extensionCreateInfo = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext);
+
+ while(extensionCreateInfo)
+ {
+ switch(extensionCreateInfo->sType)
+ {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+ {
+ const VkRenderPassInputAttachmentAspectCreateInfo* inputAttachmentAspectCreateInfo = reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(extensionCreateInfo);
+
+ for(uint32_t i = 0; i < inputAttachmentAspectCreateInfo->aspectReferenceCount; i++)
+ {
+ const VkInputAttachmentAspectReference& aspectReference = inputAttachmentAspectCreateInfo->pAspectReferences[i];
+ ASSERT(aspectReference.subpass < pCreateInfo->subpassCount);
+ const VkSubpassDescription& subpassDescription = pCreateInfo->pSubpasses[aspectReference.subpass];
+ ASSERT(aspectReference.inputAttachmentIndex < subpassDescription.inputAttachmentCount);
+ const VkAttachmentReference& attachmentReference = subpassDescription.pInputAttachments[aspectReference.inputAttachmentIndex];
+ if(attachmentReference.attachment != VK_ATTACHMENT_UNUSED)
+ {
+ // If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, for any
+ // element of the pInputAttachments member of any element of pSubpasses where the attachment member
+ // is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of
+ // VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are
+ // present in images of the format specified by the element of pAttachments at attachment
+ vk::Format format(pCreateInfo->pAttachments[attachmentReference.attachment].format);
+ bool isDepth = format.isDepth();
+ bool isStencil = format.isStencil();
+ ASSERT(!(aspectReference.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) || (!isDepth && !isStencil));
+ ASSERT(!(aspectReference.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) || isDepth);
+ ASSERT(!(aspectReference.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) || isStencil);
+ }
+ }
+ }
+ break;
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ const VkRenderPassMultiviewCreateInfo* multiviewCreateInfo = reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(extensionCreateInfo);
+ ASSERT((multiviewCreateInfo->subpassCount == 0) || (multiviewCreateInfo->subpassCount == pCreateInfo->subpassCount));
+ ASSERT((multiviewCreateInfo->dependencyCount == 0) || (multiviewCreateInfo->dependencyCount == pCreateInfo->dependencyCount));
+
+ bool zeroMask = (multiviewCreateInfo->pViewMasks[0] == 0);
+ for(uint32_t i = 1; i < multiviewCreateInfo->subpassCount; i++)
+ {
+ ASSERT((multiviewCreateInfo->pViewMasks[i] == 0) == zeroMask);
+ }
+
+ if(zeroMask)
+ {
+ ASSERT(multiviewCreateInfo->correlationMaskCount == 0);
+ }
+
+ for(uint32_t i = 0; i < multiviewCreateInfo->dependencyCount; i++)
+ {
+ const VkSubpassDependency &dependency = pCreateInfo->pDependencies[i];
+ if(multiviewCreateInfo->pViewOffsets[i] != 0)
+ {
+ ASSERT(dependency.srcSubpass != dependency.dstSubpass);
+ ASSERT(dependency.dependencyFlags & VK_DEPENDENCY_VIEW_LOCAL_BIT);
+ }
+ if(zeroMask)
+ {
+ ASSERT(!(dependency.dependencyFlags & VK_DEPENDENCY_VIEW_LOCAL_BIT));
+ }
+ }
+
+ // If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo,
+ // each element of its pViewMask member must not include a bit at a position
+ // greater than the value of VkPhysicalDeviceLimits::maxFramebufferLayers
+ // pViewMask is a 32 bit value. If maxFramebufferLayers > 32, it's impossible
+ // for pViewMask to contain a bit at an illegal position
+ // Note: Verify pViewMask values instead if we hit this assert
+ ASSERT(vk::Cast(vk::Cast(device)->getPhysicalDevice())->getProperties().limits.maxFramebufferLayers >= 32);
+ }
+ break;
+ default:
+ UNIMPLEMENTED("extensionCreateInfo->sType");
+ break;
+ }
+
+ extensionCreateInfo = extensionCreateInfo->pNext;
}
return vk::RenderPass::Create(pAllocator, pCreateInfo, pRenderPass);
VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkRenderPass renderPass = 0x%X, VkExtent2D* pGranularity = 0x%X)",
+ device, renderPass, pGranularity);
+
+ vk::Cast(renderPass)->getRenderAreaGranularity(pGranularity);
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
if(pCreateInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pCreateInfo->pNext");
}
return vk::CommandPool::Create(pAllocator, pCreateInfo, pCommandPool);
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, VkCommandPool commandPool = 0x%X, VkCommandPoolResetFlags flags = %d )",
+ device, commandPool, flags);
+
+ return vk::Cast(commandPool)->reset(flags);
}
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
if(pAllocateInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pAllocateInfo->pNext");
}
return vk::Cast(pAllocateInfo->commandPool)->allocateCommandBuffers(
if(pBeginInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pBeginInfo->pNext");
}
return vk::Cast(commandBuffer)->begin(pBeginInfo->flags, pBeginInfo->pInheritanceInfo);
if(pRenderPassBegin->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pRenderPassBegin->pNext");
}
vk::Cast(commandBuffer)->beginRenderPass(pRenderPassBegin->renderPass, pRenderPassBegin->framebuffer,
{
if(pBindInfos[i].pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pBindInfos[%d].pNext", i);
}
vk::Cast(pBindInfos[i].buffer)->bind(pBindInfos[i].memory, pBindInfos[i].memoryOffset);
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkBindImageMemory2");
return VK_SUCCESS;
}
device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
ASSERT(localDeviceIndex != remoteDeviceIndex); // "localDeviceIndex must not equal remoteDeviceIndex"
- UNREACHABLE(remoteDeviceIndex); // Only one physical device is supported, and since the device indexes can't be equal, this should never be called.
+ UNREACHABLE("remoteDeviceIndex: %d", int(remoteDeviceIndex)); // Only one physical device is supported, and since the device indexes can't be equal, this should never be called.
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkCmdSetDeviceMask");
}
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)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkCmdDispatchBase");
}
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
if(pInfo->pNext || pMemoryRequirements->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pInfo->pNext || pMemoryRequirements->pNext");
}
vkGetImageMemoryRequirements(device, pInfo->image, &(pMemoryRequirements->memoryRequirements));
TRACE("(VkDevice device = 0x%X, const VkBufferMemoryRequirementsInfo2* pInfo = 0x%X, VkMemoryRequirements2* pMemoryRequirements = 0x%X)",
device, pInfo, pMemoryRequirements);
- if(pInfo->pNext || pMemoryRequirements->pNext)
+ if(pInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pInfo->pNext");
+ }
+
+ VkBaseOutStructure* extensionRequirements = reinterpret_cast<VkBaseOutStructure*>(pMemoryRequirements->pNext);
+ while(extensionRequirements)
+ {
+ switch(extensionRequirements->sType)
+ {
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+ {
+ auto& requirements = *reinterpret_cast<VkMemoryDedicatedRequirements*>(extensionRequirements);
+ requirements.prefersDedicatedAllocation = VK_FALSE;
+ requirements.requiresDedicatedAllocation = VK_FALSE;
+ }
+ break;
+ default:
+ UNIMPLEMENTED("extensionRequirements->sType");
+ break;
+ }
+
+ extensionRequirements = extensionRequirements->pNext;
}
vkGetBufferMemoryRequirements(device, pInfo->buffer, &(pMemoryRequirements->memoryRequirements));
if(pInfo->pNext || pSparseMemoryRequirements->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pInfo->pNext || pSparseMemoryRequirements->pNext");
}
vkGetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &(pSparseMemoryRequirements->memoryRequirements));
break;
default:
// "the [driver] must skip over, without processing (other than reading the sType and pNext members) any structures in the chain with sType values not defined by [supported extenions]"
- UNIMPLEMENTED(); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
+ UNIMPLEMENTED("extensionFeatures->sType"); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
break;
}
vk::Cast(physicalDevice)->getProperties(&properties);
}
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ // Explicitly ignored, since VK_EXT_sample_locations is not supported
+ ASSERT(!HasExtensionProperty(VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME, deviceExtensionProperties,
+ sizeof(deviceExtensionProperties) / sizeof(deviceExtensionProperties[0])));
+ break;
default:
// "the [driver] must skip over, without processing (other than reading the sType and pNext members) any structures in the chain with sType values not defined by [supported extenions]"
- UNIMPLEMENTED(); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
+ UNIMPLEMENTED("extensionProperties->sType"); // TODO(b/119321052): UNIMPLEMENTED() should be used only for features that must still be implemented. Use a more informational macro here.
break;
}
if(pFormatProperties->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pFormatProperties->pNext");
}
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &(pFormatProperties->formatProperties));
if(pImageFormatInfo->pNext || pImageFormatProperties->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pImageFormatInfo->pNext || pImageFormatProperties->pNext");
}
return vkGetPhysicalDeviceImageFormatProperties(physicalDevice,
if(pQueueFamilyProperties && pQueueFamilyProperties->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pQueueFamilyProperties->pNext");
}
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
if(pMemoryProperties->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pMemoryProperties->pNext");
}
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &(pMemoryProperties->memoryProperties));
if(pProperties && pProperties->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pProperties->pNext");
}
vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type,
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkCommandPool commandPool = 0x%X, VkCommandPoolTrimFlags flags = %d)",
+ device, commandPool, flags);
+
+ vk::Cast(commandPool)->trim(flags);
}
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
if(pQueueInfo->pNext)
{
- UNIMPLEMENTED();
+ UNIMPLEMENTED("pQueueInfo->pNext");
}
// The only flag that can be set here is VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkCreateSamplerYcbcrConversion");
return VK_SUCCESS;
}
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
{
TRACE("()");
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkDestroySamplerYcbcrConversion");
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
- TRACE("()");
- UNIMPLEMENTED();
- return VK_SUCCESS;
+ TRACE("(VkDevice device = 0x%X, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate = 0x%X)",
+ device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+
+ if(pCreateInfo->pNext || pCreateInfo->flags || (pCreateInfo->templateType != VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET))
+ {
+ UNIMPLEMENTED("pCreateInfo->pNext || pCreateInfo->flags || (pCreateInfo->templateType != VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET)");
+ }
+
+ return vk::DescriptorUpdateTemplate::Create(pAllocator, pCreateInfo, pDescriptorUpdateTemplate);
}
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkDescriptorUpdateTemplate descriptorUpdateTemplate = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, descriptorUpdateTemplate, pAllocator);
+
+ vk::destroy(descriptorUpdateTemplate, pAllocator);
}
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
{
- TRACE("()");
- UNIMPLEMENTED();
+ TRACE("(VkDevice device = 0x%X, VkDescriptorSet descriptorSet = 0x%X, VkDescriptorUpdateTemplate descriptorUpdateTemplate = 0x%X, const void* pData = 0x%X)",
+ device, descriptorSet, descriptorUpdateTemplate, pData);
+
+ vk::Cast(descriptorUpdateTemplate)->updateDescriptorSet(descriptorSet, pData);
}
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo = 0x%X, VkExternalBufferProperties* pExternalBufferProperties = 0x%X)",
physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkGetPhysicalDeviceExternalBufferProperties");
}
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo = 0x%X, VkExternalFenceProperties* pExternalFenceProperties = 0x%X)",
physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkGetPhysicalDeviceExternalFenceProperties");
}
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo = 0x%X, VkExternalSemaphoreProperties* pExternalSemaphoreProperties = 0x%X)",
physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
- UNIMPLEMENTED();
+ UNIMPLEMENTED("vkGetPhysicalDeviceExternalSemaphoreProperties");
}
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
vk::Cast(device)->getDescriptorSetLayoutSupport(pCreateInfo, pSupport);
}
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+ TRACE("(VkInstance instance = 0x%X, VkXlibSurfaceCreateInfoKHR* pCreateInfo = 0x%X, VkAllocationCallbacks* pAllocator = 0x%X, VkSurface* pSurface = 0x%X)",
+ instance, pCreateInfo, pAllocator, pSurface);
+
+ return vk::XlibSurfaceKHR::Create(pAllocator, pCreateInfo, pSurface);
+}
+#endif
+
+#ifndef __ANDROID__
+VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkInstance instance = 0x%X, VkSurfaceKHR surface = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ instance, surface, pAllocator);
+
+ vk::destroy(surface, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, uint32_t queueFamilyIndex = 0x%X, VkSurface surface = 0x%X, VKBool32* pSupported = 0x%X)",
+ physicalDevice, queueFamilyIndex, surface, pSupported);
+
+ *pSupported = VK_TRUE;
+ return VK_SUCCESS;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkSurfaceKHR surface = 0x%X, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities = 0x%X)",
+ physicalDevice, surface, pSurfaceCapabilities);
+
+ vk::Cast(surface)->getSurfaceCapabilities(pSurfaceCapabilities);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkSurfaceKHR surface = 0x%X. uint32_t* pSurfaceFormatCount = 0x%X, VkSurfaceFormatKHR* pSurfaceFormats)",
+ physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+
+ if(!pSurfaceFormats)
+ {
+ *pSurfaceFormatCount = vk::Cast(surface)->getSurfaceFormatsCount();
+ return VK_SUCCESS;
+ }
+
+ return vk::Cast(surface)->getSurfaceFormats(pSurfaceFormatCount, pSurfaceFormats);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkSurfaceKHR surface = 0x%X uint32_t* pPresentModeCount = 0x%X, VkPresentModeKHR* pPresentModes = 0x%X)",
+ physicalDevice, surface, pPresentModeCount, pPresentModes);
+
+ if(!pPresentModes)
+ {
+ *pPresentModeCount = vk::Cast(surface)->getPresentModeCount();
+ return VK_SUCCESS;
+ }
+
+ return vk::Cast(surface)->getPresentModes(pPresentModeCount, pPresentModes);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
+{
+ TRACE("(VkDevice device = 0x%X, const VkSwapchainCreateInfoKHR* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkSwapchainKHR* pSwapchain = 0x%X)",
+ device, pCreateInfo, pAllocator, pSwapchain);
+
+ if(pCreateInfo->oldSwapchain)
+ {
+ vk::Cast(pCreateInfo->oldSwapchain)->retire();
+ }
+
+ if(vk::Cast(pCreateInfo->surface)->getAssociatedSwapchain() != VK_NULL_HANDLE)
+ {
+ return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
+ }
+
+ VkResult status = vk::SwapchainKHR::Create(pAllocator, pCreateInfo, pSwapchain);
+
+ if(status != VK_SUCCESS)
+ {
+ return status;
+ }
+
+ status = vk::Cast(*pSwapchain)->createImages(device);
+
+ if(status != VK_SUCCESS)
+ {
+ vk::destroy(*pSwapchain, pAllocator);
+ return status;
+ }
+
+ vk::Cast(pCreateInfo->surface)->associateSwapchain(*pSwapchain);
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkSwapchainKHR swapchain = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, swapchain, pAllocator);
+
+ vk::destroy(swapchain, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
+{
+ TRACE("(VkDevice device = 0x%X, VkSwapchainKHR swapchain = 0x%X, uint32_t* pSwapchainImageCount = 0x%X, VkImage* pSwapchainImages = 0x%X)",
+ device, swapchain, pSwapchainImageCount, pSwapchainImages);
+
+ if(!pSwapchainImages)
+ {
+ *pSwapchainImageCount = vk::Cast(swapchain)->getImageCount();
+ return VK_SUCCESS;
+ }
+
+ return vk::Cast(swapchain)->getImages(pSwapchainImageCount, pSwapchainImages);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
+{
+ TRACE("(VkDevice device = 0x%X, VkSwapchainKHR swapchain = 0x%X, uint64_t timeout = 0x%X, VkSemaphore semaphore = 0x%X, VkFence fence = 0x%X, uint32_t* pImageIndex = 0x%X)",
+ device, swapchain, timeout, semaphore, fence, pImageIndex);
+
+ return vk::Cast(swapchain)->getNextImage(timeout, semaphore, fence, pImageIndex);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
+{
+ TRACE("(VkQueue queue = 0x%X, const VkPresentInfoKHR* pPresentInfo = 0x%X)",
+ queue, pPresentInfo);
+
+ vk::Cast(queue)->present(pPresentInfo);
+
+ return VK_SUCCESS;
+}
+#endif // ! __ANDROID__
+
}
OSDN Git Service
