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

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

vulkan: Update from version 0.192.0 to 0.193.0 

Change-Id: I4387b28368c38c5165c1da99d8dc4e632ad2b42a
(cherry picked from commit d0534c33c98e8f0c844b37df7c764c9dbd6bbaa3)
parent dc6d36cb

vulkan/api/vulkan.api

+63 −64
Original line number Diff line number Diff line
@@ -27,7 +27,7 @@ import platform "platform.api" 


// API version (major.minor.patch)

define VERSION_MAJOR 0

define VERSION_MINOR 192

define VERSION_MINOR 193

define VERSION_PATCH 0



// API limits
@@ -726,7 +726,7 @@ bitfield VkQueueFlagBits { 
    VK_QUEUE_GRAPHICS_BIT                                   = 0x00000001,    /// Queue supports graphics operations

    VK_QUEUE_COMPUTE_BIT                                    = 0x00000002,    /// Queue supports compute operations

    VK_QUEUE_DMA_BIT                                        = 0x00000004,    /// Queue supports DMA operations

    VK_QUEUE_SPARSE_MEMMGR_BIT                              = 0x00000008,    /// Queue supports sparse resource memory management operations

    VK_QUEUE_SPARSE_BINDING_BIT                             = 0x00000008,    /// Queue supports sparse resource memory management operations

}



/// Memory properties passed into vkAllocMemory().
@@ -840,12 +840,10 @@ bitfield VkImageCreateFlagBits { 
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = 0x00000010,    /// Allows creating image views with cube type from the created image

}



/// Framebuffer attachment view creation flags

/// Image view creation flags

type VkFlags VkImageViewCreateFlags

bitfield VkImageViewCreateFlagBits {

    VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT                = 0x00000001,

    VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT              = 0x00000002,

}

//bitfield VkImageViewCreateFlagBits {

//}



/// Pipeline creation flags

type VkFlags VkPipelineCreateFlags
@@ -970,9 +968,9 @@ bitfield VkSparseMemoryBindFlagBits { 
/// Sparse image memory requirements flags

type VkFlags VkSparseImageFormatFlags

bitfield VkSparseImageFormatFlagBits {

    VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices

    VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.

    VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT               = 0x00000004,  /// Image uses a non-standard sparse block size

    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices

    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.

    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT          = 0x00000004,  /// Image uses a non-standard sparse block size

}



/// Pipeline stages
@@ -1363,7 +1361,7 @@ class VkSparseImageFormatProperties { 
}



class VkSparseImageMemoryRequirements {

    VkSparseImageFormatProperties               formatProps

    VkSparseImageFormatProperties               formatProperties

    u32                                         imageMipTailStartLOD

    VkDeviceSize                                imageMipTailSize           /// Specified in bytes, must be a multiple of image block size / alignment

    VkDeviceSize                                imageMipTailOffset         /// Specified in bytes, must be a multiple of image block size / alignment
@@ -1545,14 +1543,14 @@ class VkImageViewCreateInfo { 
class VkBufferCopy {

    VkDeviceSize                                srcOffset              /// Specified in bytes

    VkDeviceSize                                destOffset             /// Specified in bytes

    VkDeviceSize                                copySize               /// Specified in bytes

    VkDeviceSize                                size                   /// Specified in bytes

}



class VkSparseMemoryBind {

    VkDeviceSize                                rangeOffset           /// Specified in bytes

    VkDeviceSize                                rangeSize             /// Specified in bytes

    VkDeviceSize                                memOffset             /// Specified in bytes

    VkDeviceSize                                resourceOffset        /// Specified in bytes

    VkDeviceSize                                size                  /// Specified in bytes

    VkDeviceMemory                              mem

    VkDeviceSize                                memOffset             /// Specified in bytes

    VkSparseMemoryBindFlags                     flags

}
@@ -1560,8 +1558,8 @@ class VkSparseImageMemoryBind { 
    VkImageSubresource                          subresource

    VkOffset3D                                  offset

    VkExtent3D                                  extent

    VkDeviceSize                                memOffset             /// Specified in bytes

    VkDeviceMemory                              mem

    VkDeviceSize                                memOffset             /// Specified in bytes

    VkSparseMemoryBindFlags                     flags

}
@@ -1695,13 +1693,13 @@ class VkDescriptorSetAllocInfo { 


class VkSpecializationMapEntry {

    u32                                         constantId         /// The SpecConstant ID specified in the BIL

    platform.size_t                             size               /// Size in bytes of the SpecConstant

    u32                                         offset             /// Offset of the value in the data block

    platform.size_t                             size               /// Size in bytes of the SpecConstant

}



class VkSpecializationInfo {

    u32                                         mapEntryCount      /// Number of entries in the map

    const VkSpecializationMapEntry*             pMap               /// Array of map entries

    const VkSpecializationMapEntry*             pMapEntries        /// Array of map entries

    platform.size_t                             dataSize           /// Size in bytes of pData

    const void*                                 pData              /// Pointer to SpecConstant data

}
@@ -1726,7 +1724,7 @@ class VkComputePipelineCreateInfo { 


class VkVertexInputBindingDescription {

    u32                                         binding               /// Vertex buffer binding id

    u32                                         strideInBytes  /// Distance between vertices in bytes (0 = no advancement)

    u32                                         stride                /// Distance between vertices in bytes (0 = no advancement)

    VkVertexInputStepRate                       stepRate              /// Rate at which binding is incremented

}
@@ -1734,7 +1732,7 @@ class VkVertexInputAttributeDescription { 
    u32                                         location              /// location of the shader vertex attrib

    u32                                         binding               /// Vertex buffer binding id

    VkFormat                                    format                /// format of source data

    u32                                         offsetInBytes  /// Offset of first element in bytes from base of vertex

    u32                                         offset                /// Offset of first element in bytes from base of vertex

}



class VkPipelineVertexInputStateCreateInfo {
@@ -1819,7 +1817,7 @@ class VkPipelineColorBlendStateCreateInfo { 
    VkLogicOp                                   logicOp

    u32                                         attachmentCount    /// # of pAttachments

    const VkPipelineColorBlendAttachmentState*  pAttachments

    f32[4]                                      blendConst

    f32[4]                                      blendConstants

}



class VkStencilOpState {
@@ -1881,8 +1879,8 @@ class VkPipelineCacheCreateInfo { 
    VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO

    const void*                                 pNext                 /// Pointer to next structure

    VkPipelineCacheCreateFlags                  flags

    platform.size_t                             initialSize  /// Size of initial data to populate cache, in bytes

    const void*                                 initialData  /// Initial data to populate cache

    platform.size_t                             initialDataSize       /// Size of initial data to populate cache, in bytes

    const void*                                 pInitialData          /// Initial data to populate cache

    platform.size_t                             maxSize               /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.

}
@@ -2113,7 +2111,7 @@ class VkPhysicalDeviceLimits { 
    u32                                         maxImageDimensionCube                     /// max cubemap image dimension

    u32                                         maxImageArrayLayers                       /// max layers for image arrays

    VkSampleCountFlags                          sampleCounts                              /// sample counts supported for all images supporting rendering and sampling

    u32                                         maxTexelBufferSize                        /// max texel buffer size (bytes)

    u32                                         maxTexelBufferElements

    u32                                         maxUniformBufferRange                     /// max uniform buffer size (bytes)

    u32                                         maxStorageBufferRange                     /// max storage buffer size (bytes)

    u32                                         maxPushConstantsSize                      /// max size of the push constants pool (bytes)
@@ -2229,7 +2227,7 @@ class VkPhysicalDeviceLimits { 


class VkPhysicalDeviceSparseProperties {

    VkBool32                                    residencyStandard2DBlockShape             /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)

    VkBool32                                    residencyStandard2DMSBlockShape           /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)

    VkBool32                                    residencyStandard2DMultisampleBlockShape  /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)

    VkBool32                                    residencyStandard3DBlockShape             /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)

    VkBool32                                    residencyAlignedMipSize                   /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail

    VkBool32                                    residencyNonResident                      /// Sparse resources support: GPU can safely access non-resident regions of a resource, read values from read-write resources are undefined
@@ -2284,8 +2282,8 @@ class VkDispatchIndirectCmd { 
    u32                                         z

}



@extension("VK_EXT_KHR_swapchain")

class VkSurfacePropertiesKHR {

@extension("VK_EXT_KHR_surface")

class VkSurfaceCapabilitiesKHR {

    u32                                         minImageCount

    u32                                         maxImageCount

    VkExtent2D                                  currentExtent
@@ -2298,7 +2296,7 @@ class VkSurfacePropertiesKHR { 
    VkImageUsageFlags                           supportedUsageFlags

}



@extension("VK_EXT_KHR_swapchain")

@extension("VK_EXT_KHR_surface")

class VkSurfaceFormatKHR {

    VkFormat                                    format

    VkColorSpaceKHR                             colorSpace
@@ -2329,6 +2327,8 @@ class VkSwapchainCreateInfoKHR { 
class VkPresentInfoKHR {

    VkStructureType                             sType

    const void*                                 pNext

    u32                                         waitSemaphoreCount

    const VkSemaphore*                          pWaitSemaphores

    u32                                         swapchainCount

    const VkSwapchainKHR*                       pSwapchains

    const u32*                                  imageIndices
@@ -2727,7 +2727,7 @@ cmd void vkGetDeviceQueue( 
cmd VkResult vkQueueSubmit(

        VkQueue                                     queue,

        u32                                         submitCount,

        const VkSubmitInfo*                         pSubmitInfo,

        const VkSubmitInfo*                         pSubmits,

        VkFence                                     fence) {

    queueObject := GetQueue(queue)
@@ -3709,21 +3709,21 @@ cmd VkResult vkFreeDescriptorSets( 


cmd void vkUpdateDescriptorSets(

        VkDevice                                    device,

        u32                                         writeCount,

        u32                                         descriptorWriteCount,

        const VkWriteDescriptorSet*                 pDescriptorWrites,

        u32                                         copyCount,

        u32                                         descriptorCopyCount,

        const VkCopyDescriptorSet*                  pDescriptorCopies) {

    deviceObject := GetDevice(device)



    descriptorWrites := pDescriptorWrites[0:writeCount]

    for i in (0 .. writeCount) {

    descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]

    for i in (0 .. descriptorWriteCount) {

        descriptorWrite := descriptorWrites[i]

        descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet)

        assert(descriptorWriteObject.device == device)

    }



    descriptorCopies := pDescriptorCopies[0:copyCount]

    for i in (0 .. copyCount) {

    descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]

    for i in (0 .. descriptorCopyCount) {

        descriptorCopy := descriptorCopies[i]

        descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet)

        assert(descriptorCopyObject.device == device)
@@ -3987,7 +3987,7 @@ cmd void vkCmdSetBlendConstants( 
        // TODO(jessehall): apic only supports 'const' on pointer types. Using

        // an annotation as a quick hack to pass this to the template without

        // having to modify the AST and semantic model.

        @readonly f32[4]                            blendConst) {

        @readonly f32[4]                            blendConstants) {

    cmdBufferObject := GetCmdBuffer(cmdBuffer)

    cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)

}
@@ -4330,7 +4330,7 @@ cmd void vkCmdFillBuffer( 
        VkCmdBuffer                                 cmdBuffer,

        VkBuffer                                    destBuffer,

        VkDeviceSize                                destOffset,

        VkDeviceSize                                fillSize,

        VkDeviceSize                                size,

        u32                                         data) {

    cmdBufferObject := GetCmdBuffer(cmdBuffer)

    destBufferObject := GetBuffer(destBuffer)
@@ -4643,34 +4643,33 @@ cmd void vkDestroySurfaceKHR( 
cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(

        VkPhysicalDevice                            physicalDevice,

        u32                                         queueFamilyIndex,

        VkSurfaceKHR                                surface) {

        VkSurfaceKHR                                surface,

        VkBool32*                                   pSupported) {

    physicalDeviceObject := GetPhysicalDevice(physicalDevice)



    //supported := ?



    return ?//supported

    return ?

}



@extension("VK_EXT_KHR_swapchain")

cmd VkResult vkGetSurfacePropertiesKHR(

        VkDevice                                    device,

@extension("VK_EXT_KHR_surface")

cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(

        VkPhysicalDevice                            physicalDevice,

        VkSurfaceKHR                                surface,

        VkSurfacePropertiesKHR*                     pSurfaceProperties) {

    deviceObject := GetDevice(device)

        VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities) {

    physicalDeviceObject := GetPhysicalDevice(physicalDevice)



    surfaceProperties := ?

    pSurfaceProperties[0] = surfaceProperties

    surfaceCapabilities := ?

    pSurfaceCapabilities[0] = surfaceCapabilities



    return ?

}



@extension("VK_EXT_KHR_swapchain")

cmd VkResult vkGetSurfaceFormatsKHR(

        VkDevice                                    device,

@extension("VK_EXT_KHR_surface")

cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(

        VkPhysicalDevice                            physicalDevice,

        VkSurfaceKHR                                surface,

        u32*                                        pSurfaceFormatCount,

        VkSurfaceFormatKHR*                         pSurfaceFormats) {

    deviceObject := GetDevice(device)

    physicalDeviceObject := GetPhysicalDevice(physicalDevice)



    count := as!u32(?)

    pSurfaceFormatCount[0] = count
@@ -4684,13 +4683,13 @@ cmd VkResult vkGetSurfaceFormatsKHR( 
    return ?

}



@extension("VK_EXT_KHR_swapchain")

cmd VkResult vkGetSurfacePresentModesKHR(

        VkDevice                                    device,

@extension("VK_EXT_KHR_surface")

cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(

        VkPhysicalDevice                            physicalDevice,

        VkSurfaceKHR                                surface,

        u32*                                        pPresentModeCount,

        VkPresentModeKHR*                           pPresentModes) {

    deviceObject := GetDevice(device)

    physicalDeviceObject := GetPhysicalDevice(physicalDevice)



    count := as!u32(?)

    pPresentModeCount[0] = count

vulkan/include/vulkan/vulkan.h

+85 −86

File changed.

Preview size limit exceeded, changes collapsed.

vulkan/libvulkan/entry.cpp

+16 −16
Original line number Diff line number Diff line
@@ -132,8 +132,8 @@ void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queue 
}



__attribute__((visibility("default")))

VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {

    return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmitInfo, fence);

VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {

    return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmits, fence);

}



__attribute__((visibility("default")))
@@ -447,8 +447,8 @@ VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, 
}



__attribute__((visibility("default")))

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

    GetVtbl(device).UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);

void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {

    GetVtbl(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);

}



__attribute__((visibility("default")))
@@ -542,8 +542,8 @@ void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, flo 
}



__attribute__((visibility("default")))

void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {

    GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConst);

void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) {

    GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConstants);

}



__attribute__((visibility("default")))
@@ -642,8 +642,8 @@ void vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize 
}



__attribute__((visibility("default")))

void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {

    GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);

void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) {

    GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);

}



__attribute__((visibility("default")))
@@ -742,23 +742,23 @@ void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) { 
}



__attribute__((visibility("default")))

VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {

    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface);

VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {

    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);

}



__attribute__((visibility("default")))

VkResult vkGetSurfacePropertiesKHR(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties) {

    return GetVtbl(device).GetSurfacePropertiesKHR(device, surface, pSurfaceProperties);

VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {

    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);

}



__attribute__((visibility("default")))

VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {

    return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);

VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {

    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);

}



__attribute__((visibility("default")))

VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {

    return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);

VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {

    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);

}



__attribute__((visibility("default")))

vulkan/libvulkan/get_proc_addr.cpp

+9 −21
Original line number Diff line number Diff line
@@ -64,6 +64,9 @@ const NameProcEntry kInstanceProcTbl[] = { 
    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},

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

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

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

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

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

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

    // clang-format on

};
@@ -181,9 +184,6 @@ const NameProcEntry kDeviceProcTbl[] = { 
    {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},

    {"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)},
@@ -221,6 +221,9 @@ const NameOffsetEntry kInstanceOffsetTbl[] = { 
    {"vkGetPhysicalDeviceProperties", offsetof(InstanceVtbl, GetPhysicalDeviceProperties)},

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

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

    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceCapabilitiesKHR)},

    {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceFormatsKHR)},

    {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfacePresentModesKHR)},

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

    // clang-format on

};
@@ -338,9 +341,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = { 
    {"vkGetPipelineCacheData", offsetof(DeviceVtbl, GetPipelineCacheData)},

    {"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)},
@@ -486,6 +486,9 @@ bool LoadInstanceVtbl(VkInstance instance, 
    }

    vtbl.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));

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

    vtbl.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));

    vtbl.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));

    vtbl.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));

    vtbl.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));

    // clang-format on

    return success;
@@ -1112,21 +1115,6 @@ 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");

vulkan/libvulkan/loader.cpp

+3 −9

File changed.

Preview size limit exceeded, changes collapsed.