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

Commit 88594d74 authored by Michael Lentine's avatar Michael Lentine Committed by Jesse Hall
Browse files

Add WSI functions to the loader. 

Modify vulkan.api to include the WSI functions.
Add new wsi functions to generation in get_proc_addr.cpp.tmpl
Add bottom entry points because the WSI functions are not exposed in the
driver.

Change-Id: I63c3a099a489496205b0a9eb82c005a5a48642a1
(cherry picked from commit 23b68ac9fcd2df06ffcc25cf8c4f794dd447bbd1)
parent ab9aeef0

vulkan/api/vulkan.api

+280 −0
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ type u32 VkSampleMask 
@nonDispatchHandle type u64 VkFramebuffer

@nonDispatchHandle type u64 VkRenderPass

@nonDispatchHandle type u64 VkPipelineCache

@nonDispatchHandle type u64 VkSwapchainKHR





/////////////
@@ -635,6 +636,44 @@ enum VkDynamicState { 
    VK_DYNAMIC_STATE_STENCIL_REFERENCE                      = 0x00000008,

}



//////////////////

//  Extensions  //

//////////////////



@extension("VK_EXT_KHR_swapchain")

enum VkSurfaceTransformKHR {

    VK_SURFACE_TRANSFORM_NONE_KHR                           = 0x00000000,

    VK_SURFACE_TRANSFORM_ROT90_KHR                          = 0x00000001,

    VK_SURFACE_TRANSFORM_ROT180_KHR                         = 0x00000002,

    VK_SURFACE_TRANSFORM_ROT270_KHR                         = 0x00000003,

    VK_SURFACE_TRANSFORM_HMIRROR_KHR                        = 0x00000004,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR                  = 0x00000005,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR                 = 0x00000006,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR                 = 0x00000007,

    VK_SURFACE_TRANSFORM_INHERIT_KHR                        = 0x00000008,

}



@extension("VK_EXT_KHR_swapchain")

enum VkPlatformKHR {

    VK_PLATFORM_WIN32_KHR                                   = 0x00000000,

    VK_PLATFORM_X11_KHR                                     = 0x00000001,

    VK_PLATFORM_XCB_KHR                                     = 0x00000002,

    VK_PLATFORM_ANDROID_KHR                                 = 0x00000003,

    VK_PLATFORM_WAYLAND_KHR                                 = 0x00000004,

    VK_PLATFORM_MIR_KHR                                     = 0x00000005,

}



@extension("VK_EXT_KHR_device_swapchain")

enum VkPresentModeKHR {

    VK_PRESENT_MODE_IMMEDIATE_KHR                           = 0x00000000,

    VK_PRESENT_MODE_MAILBOX_KHR                             = 0x00000001,

    VK_PRESENT_MODE_FIFO_KHR                                = 0x00000002,

}



@extension("VK_EXT_KHR_device_swapchain")

enum VkColorSpaceKHR {

    VK_COLORSPACE_SRGB_NONLINEAR_KHR                        = 0x00000000,

}



/////////////////

//  Bitfields  //
@@ -927,6 +966,22 @@ bitfield VkStencilFaceFlags { 
    VK_STENCIL_FACE_BACK_BIT                                = 0x00000002,   /// Back face

}



//////////////////

//  Extensions  //

//////////////////



@extension("VK_EXT_KHR_swapchain")

bitfield VkSurfaceTransformFlagsKHR {

    VK_SURFACE_TRANSFORM_NONE_BIT_KHR                       = 0x00000001,

    VK_SURFACE_TRANSFORM_ROT90_BIT_KHR                      = 0x00000002,

    VK_SURFACE_TRANSFORM_ROT180_BIT_KHR                     = 0x00000004,

    VK_SURFACE_TRANSFORM_ROT270_BIT_KHR                     = 0x00000008,

    VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR                    = 0x00000010,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR              = 0x00000020,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR             = 0x00000040,

    VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR             = 0x00000080,

    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR                    = 0x00000100,

}



//////////////////

//  Structures  //
@@ -1937,6 +1992,72 @@ class VkDispatchIndirectCmd { 
    u32                                         z

}



//////////////////

//  Extensions  //

//////////////////



@extension("VK_EXT_KHR_device_swapchain")

class VkSurfacePropertiesKHR {

    u32                                     minImageCount

    u32                                     maxImageCount

    VkExtent2D                              currentExtent

    VkExtent2D                              minImageExtent

    VkExtent2D                              maxImageExtent

    VkSurfaceTransformFlagsKHR              supportedTransforms

    VkSurfaceTransformKHR                   currentTransform

    u32                                     maxImageArraySize

    VkImageUsageFlags                       supportedUsageFlags

}



@extension("VK_EXT_KHR_device_swapchain")

class VkSurfaceFormatKHR {

    VkFormat                                format

    VkColorSpaceKHR                         colorSpace

}



@extension("VK_EXT_KHR_device_swapchain")

class VkSwapchainCreateInfoKHR {

    VkStructureType                          sType

    const void*                              pNext

    const VkSurfaceDescriptionKHR*           pSurfaceDescription

    u32                                      minImageCount

    VkFormat                                 imageFormat

    VkColorSpaceKHR                          imageColorSpace

    VkExtent2D                               imageExtent

    VkImageUsageFlags                        imageUsageFlags

    VkSurfaceTransformKHR                    preTransform

    u32                                      imageArraySize

    VkSharingMode                            sharingMode

    u32                                      queueFamilyCount

    const u32*                               pQueueFamilyIndices

    VkPresentModeKHR                         presentMode

    VkSwapchainKHR                           oldSwapchain

    VkBool32                                 clipped

}



@extension("VK_EXT_KHR_device_swapchain")

class VkPresentInfoKHR {

    VkStructureType                          sType

    const void*                              pNext

    u32                                      swapchainCount

    const VkSwapchainKHR*                    swapchains

    const u32*                               imageIndices

}



@extension("VK_EXT_KHR_swapchain")

class VkSurfaceDescriptionKHR {

    VkStructureType                          sType

    const void*                              pNext

}



@extension("VK_EXT_KHR_swapchain")

class VkSurfaceDescriptionWindowKHR {

    VkStructureType                         sType

    const void*                             pNext

    VkPlatformKHR                           platform

    void*                                   pPlatformHandle

    void*                                   pPlatformWindow

}



////////////////

//  Commands  //
@@ -4210,6 +4331,155 @@ cmd void vkCmdExecuteCommands( 
    }

}



////////////////

// Extensions //

////////////////



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkGetSurfacePropertiesKHR(

        VkDevice                                 device,

        const VkSurfaceDescriptionKHR*           pSurfaceDescription,

        VkSurfacePropertiesKHR*                  pSurfaceProperties) {

    deviceObject := GetDevice(device)



    surfaceProperties := ?

    pSurfaceProperties[0] = surfaceProperties



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkGetSurfaceFormatsKHR(

        VkDevice                                 device,

        const VkSurfaceDescriptionKHR*           pSurfaceDescription,

        u32*                                     pCount,

        VkSurfaceFormatKHR*                      pSurfaceFormats) {

    deviceObject := GetDevice(device)



    count := as!u32(?)

    pCount[0] = count

    surfaceFormats := pSurfaceFormats[0:count]



    for i in (0 .. count) {

        surfaceFormat := ?

        surfaceFormats[i] = surfaceFormat

    }



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkGetSurfacePresentModesKHR(

        VkDevice                                 device,

        const VkSurfaceDescriptionKHR*           pSurfaceDescription,

        u32*                                     pCount,

        VkPresentModeKHR*                        pPresentModes) {

    deviceObject := GetDevice(device)



    count := as!u32(?)

    pCount[0] = count

    presentModes := pPresentModes[0:count]



    for i in (0 .. count) {

        presentMode := ?

        presentModes[i] = presentMode

    }



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkCreateSwapchainKHR(

        VkDevice                                 device,

        const VkSwapchainCreateInfoKHR*          pCreateInfo,

        VkSwapchainKHR*                          pSwapchain) {

    //assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)

    deviceObject := GetDevice(device)



    swapchain := ?

    pSwapchain[0] = swapchain

    State.Swapchains[swapchain] = new!SwapchainObject(device: device)



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkDestroySwapchainKHR(

        VkDevice                                 device,

        VkSwapchainKHR                           swapchain) {

    deviceObject := GetDevice(device)

    swapchainObject := GetSwapchain(swapchain)

    assert(swapchainObject.device == device)



    State.Swapchains[swapchain] = null



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkGetSwapchainImagesKHR(

        VkDevice                                 device,

        VkSwapchainKHR                           swapchain,

        u32*                                     pCount,

        VkImage*                                 pSwapchainImages) {

    deviceObject := GetDevice(device)



    count := as!u32(?)

    pCount[0] = count

    swapchainImages := pSwapchainImages[0:count]



    for i in (0 .. count) {

        swapchainImage := ?

        swapchainImages[i] = swapchainImage

        if !(swapchainImage in State.Images) {

            State.Images[swapchainImage] = new!ImageObject(device: device)

        }

    }



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkAcquireNextImageKHR(

        VkDevice                                 device,

        VkSwapchainKHR                           swapchain,

        u64                                      timeout,

        VkSemaphore                              semaphore,

        u32*                                     pImageIndex) {

    deviceObject := GetDevice(device)

    swapchainObject := GetSwapchain(swapchain)



    imageIndex := ?

    pImageIndex[0] = imageIndex



    return ?

}



@extension("VK_EXT_KHR_device_swapchain")

cmd VkResult vkQueuePresentKHR(

        VkQueue                                  queue,

        VkPresentInfoKHR*                        pPresentInfo) {

    queueObject := GetQueue(queue)



    presentInfo := ?

    pPresentInfo[0] = presentInfo



    return ?

}



@extension("VK_EXT_KHR_swapchain")

cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(

        VkPhysicalDevice                        physicalDevice,

        u32                                     queueFamilyIndex,

        const VkSurfaceDescriptionKHR*          pSurfaceDescription,

        VkBool32*                               pSupported) {

    physicalDeviceObject := GetPhysicalDevice(physicalDevice)



    supported := ?

    pSupported[0] = supported



    return ?

}



////////////////

// Validation //
@@ -4254,6 +4524,7 @@ StateObject State 
    map!(VkRenderPass,               ref!RenderPassObject)               RenderPasses

    map!(VkPipelineCache,            ref!PipelineCacheObject)            PipelineCaches

    map!(VkCmdPool,                  ref!CmdPoolObject)                  CmdPools

    map!(VkSwapchainKHR,             ref!SwapchainObject)                Swapchains

}



@internal class InstanceObject {
@@ -4372,6 +4643,10 @@ StateObject State 
    VkDevice      device

}



@internal class SwapchainObject {

    VkDevice      device

}



macro ref!InstanceObject GetInstance(VkInstance instance) {

    assert(instance in State.Instances)

    return State.Instances[instance]
@@ -4501,3 +4776,8 @@ macro ref!CmdPoolObject GetCmdPool(VkCmdPool cmdPool) { 
    assert(cmdPool in State.CmdPools)

    return State.CmdPools[cmdPool]

}



macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {

    assert(swapchain in State.Swapchains)

    return State.Swapchains[swapchain]

}

vulkan/libvulkan/get_proc_addr.cpp

+62 −43
Original line number Diff line number Diff line
@@ -62,11 +62,13 @@ const NameProcEntry kInstanceProcTbl[] = { 
    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},

    {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties)},

    {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties)},

    {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR)},

    // clang-format on

};



const NameProcEntry kDeviceProcTbl[] = {

    // clang-format off

    {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},

    {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocDescriptorSets)},

    {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocMemory)},

    {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
@@ -138,6 +140,7 @@ const NameProcEntry kDeviceProcTbl[] = { 
    {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},

    {"vkCreateShader", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShader)},

    {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},

    {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},

    {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},

    {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},

    {"vkDestroyCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandBuffer)},
@@ -159,6 +162,7 @@ const NameProcEntry kDeviceProcTbl[] = { 
    {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},

    {"vkDestroyShader", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShader)},

    {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},

    {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},

    {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},

    {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer)},

    {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges)},
@@ -177,12 +181,17 @@ const NameProcEntry kDeviceProcTbl[] = { 
    {"vkGetPipelineCacheSize", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheSize)},

    {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},

    {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},

    {"vkGetSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR)},

    {"vkGetSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePresentModesKHR)},

    {"vkGetSurfacePropertiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR)},

    {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},

    {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},

    {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},

    {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},

    {"vkQueueBindSparseBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseBufferMemory)},

    {"vkQueueBindSparseImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageMemory)},

    {"vkQueueBindSparseImageOpaqueMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageOpaqueMemory)},

    {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},

    {"vkQueueSignalSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSignalSemaphore)},

    {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},

    {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
@@ -214,11 +223,13 @@ const NameOffsetEntry kInstanceOffsetTbl[] = { 
    {"vkGetPhysicalDeviceProperties", offsetof(InstanceVtbl, GetPhysicalDeviceProperties)},

    {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceVtbl, GetPhysicalDeviceQueueFamilyProperties)},

    {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceVtbl, GetPhysicalDeviceSparseImageFormatProperties)},

    {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceSupportKHR)},

    // clang-format on

};



const NameOffsetEntry kDeviceOffsetTbl[] = {

    // clang-format off

    {"vkAcquireNextImageKHR", offsetof(DeviceVtbl, AcquireNextImageKHR)},

    {"vkAllocDescriptorSets", offsetof(DeviceVtbl, AllocDescriptorSets)},

    {"vkAllocMemory", offsetof(DeviceVtbl, AllocMemory)},

    {"vkBeginCommandBuffer", offsetof(DeviceVtbl, BeginCommandBuffer)},
@@ -290,6 +301,7 @@ const NameOffsetEntry kDeviceOffsetTbl[] = { 
    {"vkCreateSemaphore", offsetof(DeviceVtbl, CreateSemaphore)},

    {"vkCreateShader", offsetof(DeviceVtbl, CreateShader)},

    {"vkCreateShaderModule", offsetof(DeviceVtbl, CreateShaderModule)},

    {"vkCreateSwapchainKHR", offsetof(DeviceVtbl, CreateSwapchainKHR)},

    {"vkDestroyBuffer", offsetof(DeviceVtbl, DestroyBuffer)},

    {"vkDestroyBufferView", offsetof(DeviceVtbl, DestroyBufferView)},

    {"vkDestroyCommandBuffer", offsetof(DeviceVtbl, DestroyCommandBuffer)},
@@ -311,6 +323,7 @@ const NameOffsetEntry kDeviceOffsetTbl[] = { 
    {"vkDestroySemaphore", offsetof(DeviceVtbl, DestroySemaphore)},

    {"vkDestroyShader", offsetof(DeviceVtbl, DestroyShader)},

    {"vkDestroyShaderModule", offsetof(DeviceVtbl, DestroyShaderModule)},

    {"vkDestroySwapchainKHR", offsetof(DeviceVtbl, DestroySwapchainKHR)},

    {"vkDeviceWaitIdle", offsetof(DeviceVtbl, DeviceWaitIdle)},

    {"vkEndCommandBuffer", offsetof(DeviceVtbl, EndCommandBuffer)},

    {"vkFlushMappedMemoryRanges", offsetof(DeviceVtbl, FlushMappedMemoryRanges)},
@@ -329,12 +342,17 @@ const NameOffsetEntry kDeviceOffsetTbl[] = { 
    {"vkGetPipelineCacheSize", offsetof(DeviceVtbl, GetPipelineCacheSize)},

    {"vkGetQueryPoolResults", offsetof(DeviceVtbl, GetQueryPoolResults)},

    {"vkGetRenderAreaGranularity", offsetof(DeviceVtbl, GetRenderAreaGranularity)},

    {"vkGetSurfaceFormatsKHR", offsetof(DeviceVtbl, GetSurfaceFormatsKHR)},

    {"vkGetSurfacePresentModesKHR", offsetof(DeviceVtbl, GetSurfacePresentModesKHR)},

    {"vkGetSurfacePropertiesKHR", offsetof(DeviceVtbl, GetSurfacePropertiesKHR)},

    {"vkGetSwapchainImagesKHR", offsetof(DeviceVtbl, GetSwapchainImagesKHR)},

    {"vkInvalidateMappedMemoryRanges", offsetof(DeviceVtbl, InvalidateMappedMemoryRanges)},

    {"vkMapMemory", offsetof(DeviceVtbl, MapMemory)},

    {"vkMergePipelineCaches", offsetof(DeviceVtbl, MergePipelineCaches)},

    {"vkQueueBindSparseBufferMemory", offsetof(DeviceVtbl, QueueBindSparseBufferMemory)},

    {"vkQueueBindSparseImageMemory", offsetof(DeviceVtbl, QueueBindSparseImageMemory)},

    {"vkQueueBindSparseImageOpaqueMemory", offsetof(DeviceVtbl, QueueBindSparseImageOpaqueMemory)},

    {"vkQueuePresentKHR", offsetof(DeviceVtbl, QueuePresentKHR)},

    {"vkQueueSignalSemaphore", offsetof(DeviceVtbl, QueueSignalSemaphore)},

    {"vkQueueSubmit", offsetof(DeviceVtbl, QueueSubmit)},

    {"vkQueueWaitIdle", offsetof(DeviceVtbl, QueueWaitIdle)},
@@ -363,10 +381,6 @@ PFN_vkVoidFunction GetGlobalInstanceProcAddr(const char* name) { 
    // bootstrapping

    if (strcmp(name, "vkGetDeviceProcAddr") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr);

    // special-case extension functions until they can be auto-generated

    if (strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(

            vkGetPhysicalDeviceSurfaceSupportKHR);

    return nullptr;

}
@@ -374,24 +388,6 @@ PFN_vkVoidFunction GetGlobalDeviceProcAddr(const char* name) { 
    const NameProcEntry* entry = FindProcEntry(kDeviceProcTbl, name);

    if (entry)

        return entry->proc;

    // special-case extension functions until they can be auto-generated

    if (strcmp(name, "vkGetSurfacePropertiesKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR);

    if (strcmp(name, "vkGetSurfaceFormatsKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR);

    if (strcmp(name, "vkGetSurfacePresentModesKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(

            vkGetSurfacePresentModesKHR);

    if (strcmp(name, "vkCreateSwapchainKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR);

    if (strcmp(name, "vkDestroySwapchainKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR);

    if (strcmp(name, "vkGetSwapchainImagesKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR);

    if (strcmp(name, "vkAcquireNextImageKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR);

    if (strcmp(name, "vkQueuePresentKHR") == 0)

        return reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR);

    return nullptr;

}
@@ -401,8 +397,6 @@ PFN_vkVoidFunction GetSpecificInstanceProcAddr(const InstanceVtbl* vtbl, 
    const NameOffsetEntry* entry = FindProcEntry(kInstanceOffsetTbl, name);

    if (entry)

        offset = entry->offset;

    else if (strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR") == 0)

        offset = offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceSupportKHR);

    else

        return nullptr;

    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
@@ -416,22 +410,6 @@ PFN_vkVoidFunction GetSpecificDeviceProcAddr(const DeviceVtbl* vtbl, 
    const NameOffsetEntry* entry = FindProcEntry(kDeviceOffsetTbl, name);

    if (entry)

        offset = entry->offset;

    else if (strcmp(name, "vkGetSurfacePropertiesKHR") == 0)

        offset = offsetof(DeviceVtbl, GetSurfacePropertiesKHR);

    else if (strcmp(name, "vkGetSurfaceFormatsKHR") == 0)

        offset = offsetof(DeviceVtbl, GetSurfaceFormatsKHR);

    else if (strcmp(name, "vkGetSurfacePresentModesKHR") == 0)

        offset = offsetof(DeviceVtbl, GetSurfacePresentModesKHR);

    else if (strcmp(name, "vkCreateSwapchainKHR") == 0)

        offset = offsetof(DeviceVtbl, CreateSwapchainKHR);

    else if (strcmp(name, "vkDestroySwapchainKHR") == 0)

        offset = offsetof(DeviceVtbl, DestroySwapchainKHR);

    else if (strcmp(name, "vkGetSwapchainImagesKHR") == 0)

        offset = offsetof(DeviceVtbl, GetSwapchainImagesKHR);

    else if (strcmp(name, "vkAcquireNextImageKHR") == 0)

        offset = offsetof(DeviceVtbl, AcquireNextImageKHR);

    else if (strcmp(name, "vkQueuePresentKHR") == 0)

        offset = offsetof(DeviceVtbl, QueuePresentKHR);

    else

        return nullptr;

    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
@@ -514,6 +492,7 @@ bool LoadInstanceVtbl(VkInstance instance, 
        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");

        success = false;

    }

    vtbl.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));

    // clang-format on

    return success;

}
@@ -1169,6 +1148,46 @@ bool LoadDeviceVtbl(VkDevice device, 
        ALOGE("missing device proc: %s", "vkCmdExecuteCommands");

        success = false;

    }

    vtbl.GetSurfacePropertiesKHR = reinterpret_cast<PFN_vkGetSurfacePropertiesKHR>(get_proc_addr(device, "vkGetSurfacePropertiesKHR"));

    if (UNLIKELY(!vtbl.GetSurfacePropertiesKHR)) {

        ALOGE("missing device proc: %s", "vkGetSurfacePropertiesKHR");

        success = false;

    }

    vtbl.GetSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetSurfaceFormatsKHR>(get_proc_addr(device, "vkGetSurfaceFormatsKHR"));

    if (UNLIKELY(!vtbl.GetSurfaceFormatsKHR)) {

        ALOGE("missing device proc: %s", "vkGetSurfaceFormatsKHR");

        success = false;

    }

    vtbl.GetSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetSurfacePresentModesKHR>(get_proc_addr(device, "vkGetSurfacePresentModesKHR"));

    if (UNLIKELY(!vtbl.GetSurfacePresentModesKHR)) {

        ALOGE("missing device proc: %s", "vkGetSurfacePresentModesKHR");

        success = false;

    }

    vtbl.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));

    if (UNLIKELY(!vtbl.CreateSwapchainKHR)) {

        ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");

        success = false;

    }

    vtbl.DestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(get_proc_addr(device, "vkDestroySwapchainKHR"));

    if (UNLIKELY(!vtbl.DestroySwapchainKHR)) {

        ALOGE("missing device proc: %s", "vkDestroySwapchainKHR");

        success = false;

    }

    vtbl.GetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(get_proc_addr(device, "vkGetSwapchainImagesKHR"));

    if (UNLIKELY(!vtbl.GetSwapchainImagesKHR)) {

        ALOGE("missing device proc: %s", "vkGetSwapchainImagesKHR");

        success = false;

    }

    vtbl.AcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(get_proc_addr(device, "vkAcquireNextImageKHR"));

    if (UNLIKELY(!vtbl.AcquireNextImageKHR)) {

        ALOGE("missing device proc: %s", "vkAcquireNextImageKHR");

        success = false;

    }

    vtbl.QueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(get_proc_addr(device, "vkQueuePresentKHR"));

    if (UNLIKELY(!vtbl.QueuePresentKHR)) {

        ALOGE("missing device proc: %s", "vkQueuePresentKHR");

        success = false;

    }

    vtbl.GetSwapchainGrallocUsageANDROID = reinterpret_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(get_proc_addr(device, "vkGetSwapchainGrallocUsageANDROID"));

    if (UNLIKELY(!vtbl.GetSwapchainGrallocUsageANDROID)) {

        // TODO(jessehall): temporarily make this optional, until drivers have been updated

vulkan/libvulkan/get_proc_addr.cpp.tmpl

+12 −39

File changed.

Preview size limit exceeded, changes collapsed.

vulkan/libvulkan/loader.cpp

+34 −9

File changed.

Preview size limit exceeded, changes collapsed.