Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cf25c417 authored by Jesse Hall's avatar Jesse Hall
Browse files

vknulldrv: Fix several entry point prototypes 

Entry point implementations were never used where the appropriate
PFN_vk* type was expected, so when the prototypes were wrong the
compiler wouldn't know or be able to tell us. Of course, this means
several of them were wrong after the update to header 0.170.2.

This change adds an explicit static_cast to the appropriate function
pointer type for each function so the compiler will issue an error
when the prototype is wrong. It also fixes all of the resulting
errors.

Change-Id: I44211353476b56c8b429ee5d7ca7a669e8a95afd
(cherry picked from commit 90018472e9c4eed2fae226bd64f29da065d4b1e7)
parent 0ecdd3ed

vulkan/nulldrv/null_driver.cpp

+30 −62
Original line number Original line Diff line number Diff line
@@ -246,9 +246,8 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) { 
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// Instance

// Instance





VkResult DestroyInstance(VkInstance instance) {

void DestroyInstance(VkInstance instance) {

    instance->alloc->pfnFree(instance->alloc->pUserData, instance);

    instance->alloc->pfnFree(instance->alloc->pUserData, instance);

    return VK_SUCCESS;

}

}





// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
@@ -328,12 +327,11 @@ VkResult CreateDevice(VkPhysicalDevice physical_device, 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyDevice(VkDevice device) {

void DestroyDevice(VkDevice device) {

    if (!device)

    if (!device)

        return VK_SUCCESS;

        return;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    alloc->pfnFree(alloc->pUserData, device);

    alloc->pfnFree(alloc->pUserData, device);

    return VK_SUCCESS;

}

}





VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {

VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
@@ -358,10 +356,9 @@ VkResult CreateCommandBuffer(VkDevice device, 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdbuf) {

void DestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdbuf) {

    const VkAllocCallbacks* alloc = device->instance->alloc;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    alloc->pfnFree(alloc->pUserData, cmdbuf);

    alloc->pfnFree(alloc->pUserData, cmdbuf);

    return VK_SUCCESS;

}

}





// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
@@ -395,11 +392,10 @@ VkResult AllocMemory(VkDevice device, 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {

void FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {

    const VkAllocCallbacks* alloc = device->instance->alloc;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    DeviceMemory* mem = GetObjectFromHandle(mem_handle);

    DeviceMemory* mem = GetObjectFromHandle(mem_handle);

    alloc->pfnFree(alloc->pUserData, mem);

    alloc->pfnFree(alloc->pUserData, mem);

    return VK_SUCCESS;

}

}





VkResult MapMemory(VkDevice,

VkResult MapMemory(VkDevice,
@@ -454,11 +450,10 @@ VkResult GetBufferMemoryRequirements(VkDevice, 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {

void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {

    const VkAllocCallbacks* alloc = device->instance->alloc;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    Buffer* buffer = GetObjectFromHandle(buffer_handle);

    Buffer* buffer = GetObjectFromHandle(buffer_handle);

    alloc->pfnFree(alloc->pUserData, buffer);

    alloc->pfnFree(alloc->pUserData, buffer);

    return VK_SUCCESS;

}

}





// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
@@ -514,11 +509,10 @@ VkResult GetImageMemoryRequirements(VkDevice, 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyImage(VkDevice device, VkImage image_handle) {

void DestroyImage(VkDevice device, VkImage image_handle) {

    const VkAllocCallbacks* alloc = device->instance->alloc;

    const VkAllocCallbacks* alloc = device->instance->alloc;

    Image* image = GetObjectFromHandle(image_handle);

    Image* image = GetObjectFromHandle(image_handle);

    alloc->pfnFree(alloc->pUserData, image);

    alloc->pfnFree(alloc->pUserData, image);

    return VK_SUCCESS;

}

}





// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
@@ -550,11 +544,9 @@ VkResult AllocDescriptorSets(VkDevice device, 
                             VkDescriptorSetUsage,

                             VkDescriptorSetUsage,

                             uint32_t count,

                             uint32_t count,

                             const VkDescriptorSetLayout*,

                             const VkDescriptorSetLayout*,

                             VkDescriptorSet* sets,

                             VkDescriptorSet* sets) {

                             uint32_t* out_count) {

    for (uint32_t i = 0; i < count; i++)

    for (uint32_t i = 0; i < count; i++)

        sets[i] = AllocHandle(device, HandleType::kDescriptorSet);

        sets[i] = AllocHandle(device, HandleType::kDescriptorSet);

    *out_count = count;

    return VK_SUCCESS;

    return VK_SUCCESS;

}

}
@@ -696,12 +688,7 @@ VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFo 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) {

VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {

    ALOGV("TODO: vk%s", __FUNCTION__);

    return VK_SUCCESS;

}



VkResult GetPhysicalDeviceLimits(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) {

    ALOGV("TODO: vk%s", __FUNCTION__);

    ALOGV("TODO: vk%s", __FUNCTION__);

    return VK_SUCCESS;

    return VK_SUCCESS;

}

}
@@ -735,8 +722,7 @@ VkResult DeviceWaitIdle(VkDevice device) { 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult UnmapMemory(VkDevice device, VkDeviceMemory mem) {

void UnmapMemory(VkDevice device, VkDeviceMemory mem) {

    return VK_SUCCESS;

}

}





VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {

VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
@@ -787,8 +773,7 @@ VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBi 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyFence(VkDevice device, VkFence fence) {

void DestroyFence(VkDevice device, VkFence fence) {

    return VK_SUCCESS;

}

}





VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {

VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
@@ -804,8 +789,7 @@ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFen 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroySemaphore(VkDevice device, VkSemaphore semaphore) {

void DestroySemaphore(VkDevice device, VkSemaphore semaphore) {

    return VK_SUCCESS;

}

}





VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) {

VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) {
@@ -817,8 +801,7 @@ VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyEvent(VkDevice device, VkEvent event) {

void DestroyEvent(VkDevice device, VkEvent event) {

    return VK_SUCCESS;

}

}





VkResult GetEventStatus(VkDevice device, VkEvent event) {

VkResult GetEventStatus(VkDevice device, VkEvent event) {
@@ -836,8 +819,7 @@ VkResult ResetEvent(VkDevice device, VkEvent event) { 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyQueryPool(VkDevice device, VkQueryPool queryPool) {

void DestroyQueryPool(VkDevice device, VkQueryPool queryPool) {

    return VK_SUCCESS;

}

}





VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) {

VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) {
@@ -845,8 +827,7 @@ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t st 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyBufferView(VkDevice device, VkBufferView bufferView) {

void DestroyBufferView(VkDevice device, VkBufferView bufferView) {

    return VK_SUCCESS;

}

}





VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {

VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
@@ -854,20 +835,16 @@ VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImage 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyImageView(VkDevice device, VkImageView imageView) {

void DestroyImageView(VkDevice device, VkImageView imageView) {

    return VK_SUCCESS;

}

}





VkResult DestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {

void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {

    return VK_SUCCESS;

}

}





VkResult DestroyShader(VkDevice device, VkShader shader) {

void DestroyShader(VkDevice device, VkShader shader) {

    return VK_SUCCESS;

}

}





VkResult DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {

void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {

    return VK_SUCCESS;

}

}





size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {

size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
@@ -885,24 +862,19 @@ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_ 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyPipeline(VkDevice device, VkPipeline pipeline) {

void DestroyPipeline(VkDevice device, VkPipeline pipeline) {

    return VK_SUCCESS;

}

}





VkResult DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {

void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {

    return VK_SUCCESS;

}

}





VkResult DestroySampler(VkDevice device, VkSampler sampler) {

void DestroySampler(VkDevice device, VkSampler sampler) {

    return VK_SUCCESS;

}

}





VkResult DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {

void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {

    return VK_SUCCESS;

}

}





VkResult DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {

void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {

    return VK_SUCCESS;

}

}





VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {

VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
@@ -910,9 +882,8 @@ VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {

void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {

    ALOGV("TODO: vk%s", __FUNCTION__);

    ALOGV("TODO: vk%s", __FUNCTION__);

    return VK_SUCCESS;

}

}





VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {

VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
@@ -920,12 +891,10 @@ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, ui 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {

void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {

    return VK_SUCCESS;

}

}





VkResult DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {

void DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {

    return VK_SUCCESS;

}

}





VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {

VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
@@ -933,8 +902,7 @@ VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkEx 
    return VK_SUCCESS;

    return VK_SUCCESS;

}

}





VkResult DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {

void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {

    return VK_SUCCESS;

}

}





VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {

VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
@@ -994,10 +962,10 @@ void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize off 
void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {

void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {

}

}





void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) {

void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {

}

}





void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) {

void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {

}

}





void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {

void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {

vulkan/nulldrv/null_driver.h

+35 −36
Original line number Original line Diff line number Diff line
@@ -27,103 +27,102 @@ PFN_vkVoidFunction LookupInstanceProcAddr(const char* name); 
PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);

PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);





// clang-format off

// clang-format off

VkResult DestroyInstance(VkInstance instance);

void DestroyInstance(VkInstance instance);

VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);

VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);

PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);

VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);

VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);

VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);

VkResult GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);

VkResult GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);

VkResult GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);

VkResult GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);

VkResult GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);

VkResult GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);

PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);

PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);

VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);

PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);

VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);

VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties);

VkResult GetPhysicalDeviceLimits(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits);

VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);

VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);

VkResult DestroyDevice(VkDevice device);

void DestroyDevice(VkDevice device);

VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);

VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);

VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);

VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);

VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);

VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);

VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);

VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);

VkResult GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);

VkResult GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);

VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);

VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);

VkResult QueueWaitIdle(VkQueue queue);

VkResult QueueWaitIdle(VkQueue queue);

VkResult DeviceWaitIdle(VkDevice device);

VkResult DeviceWaitIdle(VkDevice device);

VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);

VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);

VkResult FreeMemory(VkDevice device, VkDeviceMemory mem);

void FreeMemory(VkDevice device, VkDeviceMemory mem);

VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);

VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);

VkResult UnmapMemory(VkDevice device, VkDeviceMemory mem);

void UnmapMemory(VkDevice device, VkDeviceMemory mem);

VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);

VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);

VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);

VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);

VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);

VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);

VkResult GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);

VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);

VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);

VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);

VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);

VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);

VkResult GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);

VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);

VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);

VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);

VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);

VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);

VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);

VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);

VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);

VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);

VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);

VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);

VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);

VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);

VkResult DestroyFence(VkDevice device, VkFence fence);

void DestroyFence(VkDevice device, VkFence fence);

VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);

VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);

VkResult GetFenceStatus(VkDevice device, VkFence fence);

VkResult GetFenceStatus(VkDevice device, VkFence fence);

VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);

VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);

VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);

VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);

VkResult DestroySemaphore(VkDevice device, VkSemaphore semaphore);

void DestroySemaphore(VkDevice device, VkSemaphore semaphore);

VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore);

VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore);

VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore);

VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore);

VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);

VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);

VkResult DestroyEvent(VkDevice device, VkEvent event);

void DestroyEvent(VkDevice device, VkEvent event);

VkResult GetEventStatus(VkDevice device, VkEvent event);

VkResult GetEventStatus(VkDevice device, VkEvent event);

VkResult SetEvent(VkDevice device, VkEvent event);

VkResult SetEvent(VkDevice device, VkEvent event);

VkResult ResetEvent(VkDevice device, VkEvent event);

VkResult ResetEvent(VkDevice device, VkEvent event);

VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);

VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);

VkResult DestroyQueryPool(VkDevice device, VkQueryPool queryPool);

void DestroyQueryPool(VkDevice device, VkQueryPool queryPool);

VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);

VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);

VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);

VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);

VkResult DestroyBuffer(VkDevice device, VkBuffer buffer);

void DestroyBuffer(VkDevice device, VkBuffer buffer);

VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);

VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);

VkResult DestroyBufferView(VkDevice device, VkBufferView bufferView);

void DestroyBufferView(VkDevice device, VkBufferView bufferView);

VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);

VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);

VkResult DestroyImage(VkDevice device, VkImage image);

void DestroyImage(VkDevice device, VkImage image);

VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);

VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);

VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);

VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);

VkResult DestroyImageView(VkDevice device, VkImageView imageView);

void DestroyImageView(VkDevice device, VkImageView imageView);

VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);

VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);

VkResult DestroyShaderModule(VkDevice device, VkShaderModule shaderModule);

void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule);

VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);

VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);

VkResult DestroyShader(VkDevice device, VkShader shader);

void DestroyShader(VkDevice device, VkShader shader);

VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);

VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);

VkResult DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);

void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);

size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);

size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);

VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData);

VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData);

VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);

VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);

VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);

VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);

VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);

VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);

VkResult DestroyPipeline(VkDevice device, VkPipeline pipeline);

void DestroyPipeline(VkDevice device, VkPipeline pipeline);

VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);

VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);

VkResult DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout);

void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout);

VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);

VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);

VkResult DestroySampler(VkDevice device, VkSampler sampler);

void DestroySampler(VkDevice device, VkSampler sampler);

VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);

VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);

VkResult DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);

void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);

VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);

VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);

VkResult DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);

void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);

VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);

VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);

VkResult AllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount);

VkResult AllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);

VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);

VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);

VkResult UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);

void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);

VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);

VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);

VkResult DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);

void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);

VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);

VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);

VkResult DestroyRenderPass(VkDevice device, VkRenderPass renderPass);

void DestroyRenderPass(VkDevice device, VkRenderPass renderPass);

VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);

VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);

VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);

VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);

VkResult DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);

void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);

VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);

VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);

VkResult CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);

VkResult CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);

VkResult DestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer);

void DestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer);

VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);

VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);

VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);

VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);

VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);

VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
@@ -140,8 +139,8 @@ void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, 
void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);

void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);

void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);

void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);

void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);

void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);

void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);

void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);

void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);

void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);

void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);

void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);

void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);

void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);

void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);

void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);

vulkan/nulldrv/null_driver_gen.cpp

+148 −143

File changed.

Preview size limit exceeded, changes collapsed.

vulkan/nulldrv/null_driver_gen.cpp.tmpl

+7 −2
Original line number Original line Diff line number Diff line
@@ -68,11 +68,16 @@ PFN_vkVoidFunction LookupProcAddr(const NameProcEntry (&table)[N], const char* n 
    return nullptr;

    return nullptr;

}

}





// The reinterpret_cast<..>(static_cast<..>(..)) business is there to ensure

// that the function declaration in null_driver.h matches the function pointer

// type in vulkan.h. If we just used reinterpret_cast<>, the compiler wouldn't

// tell us if there's a mistake in null_driver.h. A better solution would be to

// generate the declarations in null_driver.h.

const NameProcEntry kInstanceProcTbl[] = {«

const NameProcEntry kInstanceProcTbl[] = {«

  // clang-format off

  // clang-format off

  {{range $f := SortBy (AllCommands $) "FunctionName"}}

  {{range $f := SortBy (AllCommands $) "FunctionName"}}

    {{if eq (Macro "Vtbl" $f) "Instance"}}

    {{if eq (Macro "Vtbl" $f) "Instance"}}

      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionNameNoPrefix" $f}})},

      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vk{{Macro "FunctionNameNoPrefix" $f}}>({{Macro "FunctionNameNoPrefix" $f}}))},

    {{end}}

    {{end}}

  {{end}}

  {{end}}

  // clang-format on

  // clang-format on
@@ -82,7 +87,7 @@ const NameProcEntry kDeviceProcTbl[] = {« 
  // clang-format off

  // clang-format off

  {{range $f := SortBy (AllCommands $) "FunctionName"}}

  {{range $f := SortBy (AllCommands $) "FunctionName"}}

    {{if eq (Macro "Vtbl" $f) "Device"}}

    {{if eq (Macro "Vtbl" $f) "Device"}}

      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionNameNoPrefix" $f}})},

      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vk{{Macro "FunctionNameNoPrefix" $f}}>({{Macro "FunctionNameNoPrefix" $f}}))},

    {{end}}

    {{end}}

  {{end}}

  {{end}}

  // clang-format on

  // clang-format on