// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 192
+define VERSION_MINOR 193
define VERSION_PATCH 0
// API limits
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().
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
/// 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
}
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
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
}
VkImageSubresource subresource
VkOffset3D offset
VkExtent3D extent
- VkDeviceSize memOffset /// Specified in bytes
VkDeviceMemory mem
+ VkDeviceSize memOffset /// Specified in bytes
VkSparseMemoryBindFlags flags
}
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
}
}
class VkVertexInputBindingDescription {
- u32 binding /// Vertex buffer binding id
- u32 strideInBytes /// Distance between vertices in bytes (0 = no advancement)
- VkVertexInputStepRate stepRate /// Rate at which binding is incremented
+ u32 binding /// Vertex buffer binding id
+ u32 stride /// Distance between vertices in bytes (0 = no advancement)
+ VkVertexInputStepRate stepRate /// Rate at which binding is incremented
}
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 location /// location of the shader vertex attrib
+ u32 binding /// Vertex buffer binding id
+ VkFormat format /// format of source data
+ u32 offset /// Offset of first element in bytes from base of vertex
}
class VkPipelineVertexInputStateCreateInfo {
VkLogicOp logicOp
u32 attachmentCount /// # of pAttachments
const VkPipelineColorBlendAttachmentState* pAttachments
- f32[4] blendConst
+ f32[4] blendConstants
}
class VkStencilOpState {
}
class VkPipelineCacheCreateInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
- const void* pNext /// Pointer to next structure
+ 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 maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
+ 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.
}
class VkPushConstantRange {
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)
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
u32 z
}
-@extension("VK_EXT_KHR_swapchain")
-class VkSurfacePropertiesKHR {
+@extension("VK_EXT_KHR_surface")
+class VkSurfaceCapabilitiesKHR {
u32 minImageCount
u32 maxImageCount
VkExtent2D currentExtent
VkImageUsageFlags supportedUsageFlags
}
-@extension("VK_EXT_KHR_swapchain")
+@extension("VK_EXT_KHR_surface")
class VkSurfaceFormatKHR {
VkFormat format
VkColorSpaceKHR colorSpace
class VkPresentInfoKHR {
VkStructureType sType
const void* pNext
+ u32 waitSemaphoreCount
+ const VkSemaphore* pWaitSemaphores
u32 swapchainCount
const VkSwapchainKHR* pSwapchains
const u32* imageIndices
cmd VkResult vkQueueSubmit(
VkQueue queue,
u32 submitCount,
- const VkSubmitInfo* pSubmitInfo,
+ const VkSubmitInfo* pSubmits,
VkFence fence) {
queueObject := GetQueue(queue)
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)
// 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)
}
VkCmdBuffer cmdBuffer,
VkBuffer destBuffer,
VkDeviceSize destOffset,
- VkDeviceSize fillSize,
+ VkDeviceSize size,
u32 data) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
destBufferObject := GetBuffer(destBuffer)
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
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
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 192, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 193, 0)
#define VK_NULL_HANDLE 0
VK_QUEUE_GRAPHICS_BIT = 0x00000001,
VK_QUEUE_COMPUTE_BIT = 0x00000002,
VK_QUEUE_DMA_BIT = 0x00000004,
- VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
+ VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
} VkQueueFlagBits;
typedef VkFlags VkQueueFlags;
} VkImageAspectFlagBits;
typedef enum {
- VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
- VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
- VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004,
+ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
+ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
} VkSparseImageFormatFlagBits;
typedef VkFlags VkSparseImageFormatFlags;
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
typedef VkFlags VkBufferViewCreateFlags;
-
-typedef enum {
- VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
- VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
-} VkImageViewCreateFlagBits;
typedef VkFlags VkImageViewCreateFlags;
typedef VkFlags VkImageAspectFlags;
typedef VkFlags VkShaderModuleCreateFlags;
uint32_t maxImageDimensionCube;
uint32_t maxImageArrayLayers;
VkSampleCountFlags sampleCounts;
- uint32_t maxTexelBufferSize;
+ uint32_t maxTexelBufferElements;
uint32_t maxUniformBufferRange;
uint32_t maxStorageBufferRange;
uint32_t maxPushConstantsSize;
typedef struct {
VkBool32 residencyStandard2DBlockShape;
- VkBool32 residencyStandard2DMSBlockShape;
+ VkBool32 residencyStandard2DMultisampleBlockShape;
VkBool32 residencyStandard3DBlockShape;
VkBool32 residencyAlignedMipSize;
VkBool32 residencyNonResident;
} VkSparseImageFormatProperties;
typedef struct {
- VkSparseImageFormatProperties formatProps;
+ VkSparseImageFormatProperties formatProperties;
uint32_t imageMipTailStartLOD;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
} VkSparseImageMemoryRequirements;
typedef struct {
- VkDeviceSize rangeOffset;
- VkDeviceSize rangeSize;
- VkDeviceSize memOffset;
+ VkDeviceSize resourceOffset;
+ VkDeviceSize size;
VkDeviceMemory mem;
+ VkDeviceSize memOffset;
VkSparseMemoryBindFlags flags;
} VkSparseMemoryBind;
VkImageSubresource subresource;
VkOffset3D offset;
VkExtent3D extent;
- VkDeviceSize memOffset;
VkDeviceMemory mem;
+ VkDeviceSize memOffset;
VkSparseMemoryBindFlags flags;
} VkSparseImageMemoryBind;
VkStructureType sType;
const void* pNext;
VkPipelineCacheCreateFlags flags;
- size_t initialSize;
- const void* initialData;
+ size_t initialDataSize;
+ const void* pInitialData;
size_t maxSize;
} VkPipelineCacheCreateInfo;
typedef struct {
uint32_t constantId;
- size_t size;
uint32_t offset;
+ size_t size;
} VkSpecializationMapEntry;
typedef struct {
uint32_t mapEntryCount;
- const VkSpecializationMapEntry* pMap;
+ const VkSpecializationMapEntry* pMapEntries;
size_t dataSize;
const void* pData;
} VkSpecializationInfo;
typedef struct {
uint32_t binding;
- uint32_t strideInBytes;
+ uint32_t stride;
VkVertexInputStepRate stepRate;
} VkVertexInputBindingDescription;
uint32_t location;
uint32_t binding;
VkFormat format;
- uint32_t offsetInBytes;
+ uint32_t offset;
} VkVertexInputAttributeDescription;
typedef struct {
VkLogicOp logicOp;
uint32_t attachmentCount;
const VkPipelineColorBlendAttachmentState* pAttachments;
- float blendConst[4];
+ float blendConstants[4];
} VkPipelineColorBlendStateCreateInfo;
typedef struct {
typedef struct {
VkDeviceSize srcOffset;
VkDeviceSize destOffset;
- VkDeviceSize copySize;
+ VkDeviceSize size;
} VkBufferCopy;
typedef struct {
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
-typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
-typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]);
+typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
VkResult VKAPI vkQueueSubmit(
VkQueue queue,
uint32_t submitCount,
- const VkSubmitInfo* pSubmitInfo,
+ const VkSubmitInfo* pSubmits,
VkFence fence);
VkResult VKAPI vkQueueWaitIdle(
void VKAPI vkUpdateDescriptorSets(
VkDevice device,
- uint32_t writeCount,
+ uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t copyCount,
+ uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies);
VkResult VKAPI vkCreateFramebuffer(
void VKAPI vkCmdSetBlendConstants(
VkCmdBuffer cmdBuffer,
- const float blendConst[4]);
+ const float blendConstants[4]);
void VKAPI vkCmdSetDepthBounds(
VkCmdBuffer cmdBuffer,
VkCmdBuffer cmdBuffer,
VkBuffer destBuffer,
VkDeviceSize destOffset,
- VkDeviceSize fillSize,
+ VkDeviceSize size,
uint32_t data);
void VKAPI vkCmdClearColorImage(
#define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
#define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
-typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
-
-#ifdef VK_PROTOTYPES
-void VKAPI vkDestroySurfaceKHR(
- VkInstance instance,
- VkSurfaceKHR surface);
-
-VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- VkSurfaceKHR surface);
-#endif
-
-#define vk_ext_khr_swapchain 1
-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
-
-#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
-#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
-#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
-#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
-#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
-
typedef enum {
VK_SURFACE_TRANSFORM_NONE_KHR = 0,
VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
uint32_t maxImageArraySize;
VkImageUsageFlags supportedUsageFlags;
-} VkSurfacePropertiesKHR;
+} VkSurfaceCapabilitiesKHR;
typedef struct {
VkFormat format;
VkColorSpaceKHR colorSpace;
} VkSurfaceFormatKHR;
+
+typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+
+#ifdef VK_PROTOTYPES
+void VKAPI vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+
+VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+#endif
+
+#define vk_ext_khr_swapchain 1
+VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
+
+#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
+#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
+#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
+
typedef struct {
VkStructureType sType;
const void* pNext;
typedef struct {
VkStructureType sType;
const void* pNext;
+ uint32_t waitSemaphoreCount;
+ const VkSemaphore* pWaitSemaphores;
uint32_t swapchainCount;
const VkSwapchainKHR* pSwapchains;
const uint32_t* imageIndices;
} VkPresentInfoKHR;
-typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties);
-typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
-typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
#ifdef VK_PROTOTYPES
-VkResult VKAPI vkGetSurfacePropertiesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- VkSurfacePropertiesKHR* pSurfaceProperties);
-
-VkResult VKAPI vkGetSurfaceFormatsKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormatKHR* pSurfaceFormats);
-
-VkResult VKAPI vkGetSurfacePresentModesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes);
-
VkResult VKAPI vkCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
} VkDisplayModeCreateInfoKHR;
typedef struct {
- VkDisplayKHR currentDisplay;
- uint32_t currentStackIndex;
-} VkDisplayPlanePropertiesKHR;
-
-typedef struct {
VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
VkOffset2D minSrcPosition;
VkOffset2D maxSrcPosition;
} VkDisplayPlaneCapabilitiesKHR;
typedef struct {
+ VkDisplayKHR currentDisplay;
+ uint32_t currentStackIndex;
+} VkDisplayPlanePropertiesKHR;
+
+typedef struct {
VkStructureType sType;
const void* pNext;
VkDisplayModeKHR displayMode;
}
__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")))
}
__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")))
}
__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")))
}
__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")))
}
__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")))
{"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
};
{"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)},
{"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
};
{"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)},
}
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;
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");
return reinterpret_cast<PFN_vkVoidFunction>(Noop);
}
// WSI extensions are not in the driver so return the loader functions
- if (strcmp(name, "vkGetSurfacePropertiesKHR") == 0) {
- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePropertiesKHR);
- }
- if (strcmp(name, "vkGetSurfaceFormatsKHR") == 0) {
- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfaceFormatsKHR);
- }
- if (strcmp(name, "vkGetSurfacePresentModesKHR") == 0) {
- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePresentModesKHR);
- }
if (strcmp(name, "vkCreateSwapchainKHR") == 0) {
return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
}
.EnumerateDeviceLayerProperties = EnumerateDeviceLayerPropertiesBottom,
.GetPhysicalDeviceSparseImageFormatProperties = GetPhysicalDeviceSparseImageFormatPropertiesBottom,
.GetPhysicalDeviceSurfaceSupportKHR = GetPhysicalDeviceSurfaceSupportKHR,
+ .GetPhysicalDeviceSurfaceCapabilitiesKHR = GetPhysicalDeviceSurfaceCapabilitiesKHR,
+ .GetPhysicalDeviceSurfaceFormatsKHR = GetPhysicalDeviceSurfaceFormatsKHR,
+ .GetPhysicalDeviceSurfacePresentModesKHR = GetPhysicalDeviceSurfacePresentModesKHR,
// clang-format on
};
PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
// Layers and loader only, not implemented by drivers
+ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
PFN_vkCmdExecuteCommands CmdExecuteCommands;
// Layers and loader only, not implemented by drivers
- PFN_vkGetSurfacePropertiesKHR GetSurfacePropertiesKHR;
- PFN_vkGetSurfaceFormatsKHR GetSurfaceFormatsKHR;
- PFN_vkGetSurfacePresentModesKHR GetSurfacePresentModesKHR;
PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
uint32_t queue_family,
- VkSurfaceKHR surface);
-VkResult GetSurfacePropertiesKHR(VkDevice device,
- VkSurfaceKHR surface,
- VkSurfacePropertiesKHR* properties);
-VkResult GetSurfaceFormatsKHR(VkDevice device,
- VkSurfaceKHR surface,
- uint32_t* count,
- VkSurfaceFormatKHR* formats);
-VkResult GetSurfacePresentModesKHR(VkDevice device,
- VkSurfaceKHR surface,
- uint32_t* count,
- VkPresentModeKHR* modes);
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice pdev,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* capabilities);
+VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
+ VkSurfaceKHR surface,
+ uint32_t* count,
+ VkSurfaceFormatKHR* formats);
+VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
+ VkSurfaceKHR surface,
+ uint32_t* count,
+ VkPresentModeKHR* modes);
VkResult CreateSwapchainKHR(VkDevice device,
const VkSwapchainCreateInfoKHR* create_info,
VkSwapchainKHR* swapchain_handle);
VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
uint32_t /*queue_family*/,
- VkSurfaceKHR /*surface*/) {
+ VkSurfaceKHR /*surface*/,
+ VkBool32* pSupported) {
+ *pSupported = VK_TRUE;
return VK_SUCCESS;
}
-VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
- VkSurfaceKHR surface,
- VkSurfacePropertiesKHR* properties) {
+VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* capabilities) {
int err;
ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
return VK_ERROR_INITIALIZATION_FAILED;
}
- properties->currentExtent = VkExtent2D{width, height};
+ capabilities->currentExtent = VkExtent2D{width, height};
// TODO(jessehall): Figure out what the min/max values should be.
- properties->minImageCount = 2;
- properties->maxImageCount = 3;
+ capabilities->minImageCount = 2;
+ capabilities->maxImageCount = 3;
// TODO(jessehall): Figure out what the max extent should be. Maximum
// texture dimension maybe?
- properties->minImageExtent = VkExtent2D{1, 1};
- properties->maxImageExtent = VkExtent2D{4096, 4096};
+ capabilities->minImageExtent = VkExtent2D{1, 1};
+ capabilities->maxImageExtent = VkExtent2D{4096, 4096};
// TODO(jessehall): We can support all transforms, fix this once
// implemented.
- properties->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+ capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
// TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
- properties->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
+ capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
- properties->maxImageArraySize = 1;
+ capabilities->maxImageArraySize = 1;
// TODO(jessehall): I think these are right, but haven't thought hard about
// it. Do we need to query the driver for support of any of these?
// - VK_IMAGE_USAGE_GENERAL: maybe? does this imply cpu mappable?
// - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
// - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
- properties->supportedUsageFlags =
+ capabilities->supportedUsageFlags =
VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
return VK_SUCCESS;
}
-VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
- VkSurfaceKHR /*surface*/,
- uint32_t* count,
- VkSurfaceFormatKHR* formats) {
+VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR /*surface*/,
+ uint32_t* count,
+ VkSurfaceFormatKHR* formats) {
// TODO(jessehall): Fill out the set of supported formats. Longer term, add
// a new gralloc method to query whether a (format, usage) pair is
// supported, and check that for each gralloc format that corresponds to a
return result;
}
-VkResult GetSurfacePresentModesKHR(VkDevice /*device*/,
- VkSurfaceKHR /*surface*/,
- uint32_t* count,
- VkPresentModeKHR* modes) {
+VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR /*surface*/,
+ uint32_t* count,
+ VkPresentModeKHR* modes) {
const VkPresentModeKHR kModes[] = {
VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
};
return "COMPUTE";
case VK_QUEUE_DMA_BIT:
return "DMA";
- case VK_QUEUE_SPARSE_MEMMGR_BIT:
+ case VK_QUEUE_SPARSE_BINDING_BIT:
return "SPARSE";
}
}
OSDN Git Service
