diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/vkLayer.h | 4 | ||||
| -rw-r--r-- | include/vkWsiX11Ext.h | 10 | ||||
| -rw-r--r-- | include/vk_platform.h | 2 | ||||
| -rw-r--r-- | include/vulkan.h | 1779 |
4 files changed, 836 insertions, 959 deletions
diff --git a/include/vkLayer.h b/include/vkLayer.h index e9e8b037..793ace9a 100644 --- a/include/vkLayer.h +++ b/include/vkLayer.h @@ -31,7 +31,7 @@ typedef struct VkLayerDispatchTable_ PFN_vkCreateInstance CreateInstance; PFN_vkDestroyInstance DestroyInstance; PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; - PFN_vkGetGpuInfo GetGpuInfo; + PFN_vkGetPhysicalDeviceInfo GetPhysicalDeviceInfo; PFN_vkCreateDevice CreateDevice; PFN_vkDestroyDevice DestroyDevice; PFN_vkGetGlobalExtensionInfo GetGlobalExtensionInfo; @@ -49,7 +49,7 @@ typedef struct VkLayerDispatchTable_ PFN_vkMapMemory MapMemory; PFN_vkUnmapMemory UnmapMemory; PFN_vkPinSystemMemory PinSystemMemory; - PFN_vkGetMultiGpuCompatibility GetMultiGpuCompatibility; + PFN_vkGetMultiDeviceCompatibility GetMultiDeviceCompatibility; PFN_vkOpenSharedMemory OpenSharedMemory; PFN_vkOpenSharedSemaphore OpenSharedSemaphore; PFN_vkOpenPeerMemory OpenPeerMemory; diff --git a/include/vkWsiX11Ext.h b/include/vkWsiX11Ext.h index f260f9f5..3b39c643 100644 --- a/include/vkWsiX11Ext.h +++ b/include/vkWsiX11Ext.h @@ -80,9 +80,9 @@ typedef struct _VK_WSI_X11_PRESENT_INFO bool32_t flip; } VK_WSI_X11_PRESENT_INFO; -typedef VkResult (VKAPI *PFN_vkWsiX11AssociateConnection)(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); +typedef VkResult (VKAPI *PFN_vkWsiX11AssociateConnection)(VkPhysicalDevice gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); typedef VkResult (VKAPI *PFN_vkWsiX11GetMSC)(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); -typedef VkResult (VKAPI *PFN_vkWsiX11CreatePresentableImage)(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkWsiX11CreatePresentableImage)(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkWsiX11QueuePresent)(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence); /** @@ -98,7 +98,7 @@ typedef VkResult (VKAPI *PFN_vkWsiX11QueuePresent)(VkQueue queue, const VK_WSI_X * is supported. */ VkResult VKAPI vkWsiX11AssociateConnection( - VkPhysicalGpu gpu, + VkPhysicalDevice gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); /** @@ -113,7 +113,7 @@ VkResult VKAPI vkWsiX11GetMSC( uint64_t* pMsc); /** - * Create an VkImage that can be presented. An VkGpuMemory is created + * Create an VkImage that can be presented. An VkDeviceMemory is created * and bound automatically. The memory returned can only be used in * vkQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the * image is not allowed. @@ -122,7 +122,7 @@ VkResult VKAPI vkWsiX11CreatePresentableImage( VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); /** * Present an image to an X11 window. The presentation always occurs after diff --git a/include/vk_platform.h b/include/vk_platform.h index 26962d02..957c135e 100644 --- a/include/vk_platform.h +++ b/include/vk_platform.h @@ -76,7 +76,7 @@ extern "C" #endif #endif // !defined(VK_NO_STDINT_H) -typedef uint64_t VkGpuSize; +typedef uint64_t VkDeviceSize; typedef uint32_t bool32_t; typedef uint32_t VkSampleMask; diff --git a/include/vulkan.h b/include/vulkan.h index 4e91b433..6a302348 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -55,11 +55,11 @@ extern "C" #endif // __cplusplus VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalGpu) +VK_DEFINE_HANDLE(VkPhysicalDevice) VK_DEFINE_HANDLE(VkBaseObject) VK_DEFINE_SUBCLASS_HANDLE(VkDevice, VkBaseObject) VK_DEFINE_SUBCLASS_HANDLE(VkQueue, VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkGpuMemory, VkBaseObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDeviceMemory, VkBaseObject) VK_DEFINE_SUBCLASS_HANDLE(VkObject, VkBaseObject) VK_DEFINE_SUBCLASS_HANDLE(VkBuffer, VkObject) VK_DEFINE_SUBCLASS_HANDLE(VkBufferView, VkObject) @@ -87,12 +87,14 @@ VK_DEFINE_SUBCLASS_HANDLE(VkQueryPool, VkObject) VK_DEFINE_SUBCLASS_HANDLE(VkFramebuffer, VkObject) VK_DEFINE_SUBCLASS_HANDLE(VkRenderPass, VkObject) -#define VK_MAX_PHYSICAL_GPU_NAME 256 +#define VK_MAX_PHYSICAL_DEVICE_NAME 256 #define VK_MAX_EXTENSION_NAME 256 #define VK_LOD_CLAMP_NONE MAX_FLOAT #define VK_LAST_MIP_OR_SLICE 0xffffffff +#define VK_WHOLE_SIZE UINT64_MAX + #define VK_TRUE 1 #define VK_FALSE 0 @@ -102,25 +104,34 @@ VK_DEFINE_SUBCLASS_HANDLE(VkRenderPass, VkObject) // to represent them. This may or may not be necessary on some compilers. The // option to compile it out may allow compilers that warn about missing enumerants // in switch statements to be silenced. -#define VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF +// Using this macro is not needed for flag bit enums because those aren't used +// as storage type anywhere. +#define VK_MAX_ENUM(Prefix) VK_##Prefix##_MAX_ENUM = 0x7FFFFFFF + +// This macro defines the BEGIN_RANGE, END_RANGE, NUM, and MAX_ENUM constants for +// the enumerations. +#define VK_ENUM_RANGE(Prefix, First, Last) \ + VK_##Prefix##_BEGIN_RANGE = VK_##Prefix##_##First, \ + VK_##Prefix##_END_RANGE = VK_##Prefix##_##Last, \ + VK_NUM_##Prefix = (VK_##Prefix##_END_RANGE - VK_##Prefix##_BEGIN_RANGE + 1), \ + VK_MAX_ENUM(Prefix) + +// This is a helper macro to define the value of flag bit enum values. +#define VK_BIT(bit) (1 << (bit)) // ------------------------------------------------------------------------------------------------ // Enumerations - typedef enum VkMemoryPriority_ { - VK_MEMORY_PRIORITY_UNUSED = 0x0, - VK_MEMORY_PRIORITY_VERY_LOW = 0x1, - VK_MEMORY_PRIORITY_LOW = 0x2, - VK_MEMORY_PRIORITY_NORMAL = 0x3, - VK_MEMORY_PRIORITY_HIGH = 0x4, - VK_MEMORY_PRIORITY_VERY_HIGH = 0x5, - - VK_MEMORY_PRIORITY_BEGIN_RANGE = VK_MEMORY_PRIORITY_UNUSED, - VK_MEMORY_PRIORITY_END_RANGE = VK_MEMORY_PRIORITY_VERY_HIGH, - VK_NUM_MEMORY_PRIORITY = (VK_MEMORY_PRIORITY_END_RANGE - VK_MEMORY_PRIORITY_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkMemoryPriority) + VK_MEMORY_PRIORITY_UNUSED = 0x00000000, + VK_MEMORY_PRIORITY_VERY_LOW = 0x00000001, + VK_MEMORY_PRIORITY_LOW = 0x00000002, + VK_MEMORY_PRIORITY_NORMAL = 0x00000003, + VK_MEMORY_PRIORITY_HIGH = 0x00000004, + VK_MEMORY_PRIORITY_VERY_HIGH = 0x00000005, + + VK_ENUM_RANGE(MEMORY_PRIORITY, UNUSED, VERY_HIGH) } VkMemoryPriority; typedef enum VkImageLayout_ @@ -134,75 +145,39 @@ typedef enum VkImageLayout_ VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations - - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - VK_NUM_IMAGE_LAYOUT = (VK_IMAGE_LAYOUT_END_RANGE - VK_IMAGE_LAYOUT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkImageLayout) + + VK_ENUM_RANGE(IMAGE_LAYOUT, UNDEFINED, TRANSFER_DESTINATION_OPTIMAL) } VkImageLayout; typedef enum VkPipeEvent_ { - VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command + VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the device starts processing subsequent command VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete - VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending GPU work is complete + VK_PIPE_EVENT_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending work is complete - VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE, - VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE, - VK_NUM_PIPE_EVENT = (VK_PIPE_EVENT_END_RANGE - VK_PIPE_EVENT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPipeEvent) + VK_ENUM_RANGE(PIPE_EVENT, TOP_OF_PIPE, COMMANDS_COMPLETE) } VkPipeEvent; typedef enum VkWaitEvent_ { - VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands + VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the device starts processing subsequent commands VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives - VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE, - VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION, - VK_NUM_WAIT_EVENT = (VK_WAIT_EVENT_END_RANGE - VK_WAIT_EVENT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkWaitEvent) + VK_ENUM_RANGE(WAIT_EVENT, TOP_OF_PIPE, BEFORE_RASTERIZATION) } VkWaitEvent; -typedef enum VkMemoryOutputFlags_ -{ - VK_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes - VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes - VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes - VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes - VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, // Controls output coherency of transfer operations - VK_MAX_ENUM(VkMemoryOutputFlags) -} VkMemoryOutputFlags; - -typedef enum VkMemoryInputFlags_ -{ - VK_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads - VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads - VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, // Controls input coherency of index fetches - VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, // Controls input coherency of vertex attribute fetches - VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, // Controls input coherency of uniform buffer reads - VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, // Controls input coherency of generic shader reads - VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads - VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads - VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000100, // Controls input coherency of transfer operations - VK_MAX_ENUM(VkMemoryInputFlags) -} VkMemoryInputFlags; - typedef enum VkAttachmentLoadOp_ { VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, - VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - VK_NUM_ATTACHMENT_LOAD_OP = (VK_ATTACHMENT_LOAD_OP_END_RANGE - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkAttachmentLoadOp) + VK_ENUM_RANGE(ATTACHMENT_LOAD_OP, LOAD, DONT_CARE) } VkAttachmentLoadOp; typedef enum VkAttachmentStoreOp_ @@ -211,46 +186,34 @@ typedef enum VkAttachmentStoreOp_ VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001, VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002, - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, - VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, - VK_NUM_ATTACHMENT_STORE_OP = (VK_ATTACHMENT_STORE_OP_END_RANGE - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkAttachmentStoreOp) + VK_ENUM_RANGE(ATTACHMENT_STORE_OP, STORE, DONT_CARE) } VkAttachmentStoreOp; typedef enum VkImageType_ { - VK_IMAGE_1D = 0x00000000, - VK_IMAGE_2D = 0x00000001, - VK_IMAGE_3D = 0x00000002, + VK_IMAGE_TYPE_1D = 0x00000000, + VK_IMAGE_TYPE_2D = 0x00000001, + VK_IMAGE_TYPE_3D = 0x00000002, - VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_1D, - VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_3D, - VK_NUM_IMAGE_TYPE = (VK_IMAGE_TYPE_END_RANGE - VK_IMAGE_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkImageType) + VK_ENUM_RANGE(IMAGE_TYPE, 1D, 3D) } VkImageType; typedef enum VkImageTiling_ { - VK_LINEAR_TILING = 0x00000000, - VK_OPTIMAL_TILING = 0x00000001, + VK_IMAGE_TILING_LINEAR = 0x00000000, + VK_IMAGE_TILING_OPTIMAL = 0x00000001, - VK_IMAGE_TILING_BEGIN_RANGE = VK_LINEAR_TILING, - VK_IMAGE_TILING_END_RANGE = VK_OPTIMAL_TILING, - VK_NUM_IMAGE_TILING = (VK_IMAGE_TILING_END_RANGE - VK_IMAGE_TILING_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkImageTiling) + VK_ENUM_RANGE(IMAGE_TILING, LINEAR, OPTIMAL) } VkImageTiling; typedef enum VkImageViewType_ { - VK_IMAGE_VIEW_1D = 0x00000000, - VK_IMAGE_VIEW_2D = 0x00000001, - VK_IMAGE_VIEW_3D = 0x00000002, - VK_IMAGE_VIEW_CUBE = 0x00000003, + VK_IMAGE_VIEW_TYPE_1D = 0x00000000, + VK_IMAGE_VIEW_TYPE_2D = 0x00000001, + VK_IMAGE_VIEW_TYPE_3D = 0x00000002, + VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003, - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_1D, - VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_CUBE, - VK_NUM_IMAGE_VIEW_TYPE = (VK_IMAGE_VIEW_TYPE_END_RANGE - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkImageViewType) + VK_ENUM_RANGE(IMAGE_VIEW_TYPE, 1D, CUBE) } VkImageViewType; typedef enum VkImageAspect_ @@ -259,12 +222,17 @@ typedef enum VkImageAspect_ VK_IMAGE_ASPECT_DEPTH = 0x00000001, VK_IMAGE_ASPECT_STENCIL = 0x00000002, - VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, - VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL, - VK_NUM_IMAGE_ASPECT = (VK_IMAGE_ASPECT_END_RANGE - VK_IMAGE_ASPECT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkImageAspect) + VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, STENCIL) } VkImageAspect; +typedef enum VkBufferViewType_ +{ + VK_BUFFER_VIEW_TYPE_RAW = 0x00000000, // Raw buffer without special structure (UBO, SSBO) + VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001, // Buffer with format (TBO, IBO) + + VK_ENUM_RANGE(BUFFER_VIEW_TYPE, RAW, FORMATTED) +} VkBufferViewType; + typedef enum VkChannelSwizzle_ { VK_CHANNEL_SWIZZLE_ZERO = 0x00000000, @@ -274,10 +242,7 @@ typedef enum VkChannelSwizzle_ VK_CHANNEL_SWIZZLE_B = 0x00000004, VK_CHANNEL_SWIZZLE_A = 0x00000005, - VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, - VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, - VK_NUM_CHANNEL_SWIZZLE = (VK_CHANNEL_SWIZZLE_END_RANGE - VK_CHANNEL_SWIZZLE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkChannelSwizzle) + VK_ENUM_RANGE(CHANNEL_SWIZZLE, ZERO, A) } VkChannelSwizzle; typedef enum VkDescriptorType_ @@ -293,10 +258,7 @@ typedef enum VkDescriptorType_ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009, - VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, - VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - VK_NUM_DESCRIPTOR_TYPE = (VK_DESCRIPTOR_TYPE_END_RANGE - VK_DESCRIPTOR_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkDescriptorType) + VK_ENUM_RANGE(DESCRIPTOR_TYPE, SAMPLER, STORAGE_BUFFER_DYNAMIC) } VkDescriptorType; typedef enum VkDescriptorPoolUsage_ @@ -304,21 +266,15 @@ typedef enum VkDescriptorPoolUsage_ VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, - VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, - VK_NUM_DESCRIPTOR_POOL_USAGE = (VK_DESCRIPTOR_POOL_USAGE_END_RANGE - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkDescriptorPoolUsage) + VK_ENUM_RANGE(DESCRIPTOR_POOL_USAGE, ONE_SHOT, DYNAMIC) } VkDescriptorPoolUsage; typedef enum VkDescriptorUpdateMode_ { - VK_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000, + VK_DESCRIPTOR_UPDATE_MODE_COPY = 0x00000000, VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001, - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = VK_DESCRIPTOR_UDPATE_MODE_COPY, - VK_DESCRIPTOR_UPDATE_MODE_END_RANGE = VK_DESCRIPTOR_UPDATE_MODE_FASTEST, - VK_NUM_DESCRIPTOR_UPDATE_MODE = (VK_DESCRIPTOR_UPDATE_MODE_END_RANGE - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkDescriptorUpdateMode) + VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE, COPY, FASTEST) } VkDescriptorUpdateMode; typedef enum VkDescriptorSetUsage_ @@ -326,123 +282,93 @@ typedef enum VkDescriptorSetUsage_ VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, - VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, - VK_NUM_DESCRIPTOR_SET_USAGE = (VK_DESCRIPTOR_SET_USAGE_END_RANGE - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkDescriptorSetUsage) + VK_ENUM_RANGE(DESCRIPTOR_SET_USAGE, ONE_SHOT, STATIC) } VkDescriptorSetUsage; typedef enum VkQueryType_ { - VK_QUERY_OCCLUSION = 0x00000000, - VK_QUERY_PIPELINE_STATISTICS = 0x00000001, + VK_QUERY_TYPE_OCCLUSION = 0x00000000, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, - VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_OCCLUSION, - VK_QUERY_TYPE_END_RANGE = VK_QUERY_PIPELINE_STATISTICS, - VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkQueryType) + VK_ENUM_RANGE(QUERY_TYPE, OCCLUSION, PIPELINE_STATISTICS) } VkQueryType; typedef enum VkTimestampType_ { - VK_TIMESTAMP_TOP = 0x00000000, - VK_TIMESTAMP_BOTTOM = 0x00000001, + VK_TIMESTAMP_TYPE_TOP = 0x00000000, + VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001, - VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TOP, - VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_BOTTOM, - VK_NUM_TIMESTAMP_TYPE = (VK_TIMESTAMP_TYPE_END_RANGE - VK_TIMESTAMP_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkTimestampType) + VK_ENUM_RANGE(TIMESTAMP_TYPE, TOP, BOTTOM) } VkTimestampType; -typedef enum VkBorderColorType_ +typedef enum VkBorderColor_ { VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000, VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001, VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002, - VK_BORDER_COLOR_TYPE_BEGIN_RANGE = VK_BORDER_COLOR_OPAQUE_WHITE, - VK_BORDER_COLOR_TYPE_END_RANGE = VK_BORDER_COLOR_OPAQUE_BLACK, - VK_NUM_BORDER_COLOR_TYPE = (VK_BORDER_COLOR_TYPE_END_RANGE - VK_BORDER_COLOR_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkBorderColorType) -} VkBorderColorType; + VK_ENUM_RANGE(BORDER_COLOR, OPAQUE_WHITE, OPAQUE_BLACK) +} VkBorderColor; typedef enum VkPipelineBindPoint_ { VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, - VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, - VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, - VK_NUM_PIPELINE_BIND_POINT = (VK_PIPELINE_BIND_POINT_END_RANGE - VK_PIPELINE_BIND_POINT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPipelineBindPoint) + VK_ENUM_RANGE(PIPELINE_BIND_POINT, COMPUTE, GRAPHICS) } VkPipelineBindPoint; typedef enum VkStateBindPoint_ { - VK_STATE_BIND_VIEWPORT = 0x00000000, - VK_STATE_BIND_RASTER = 0x00000001, - VK_STATE_BIND_COLOR_BLEND = 0x00000002, - VK_STATE_BIND_DEPTH_STENCIL = 0x00000003, + VK_STATE_BIND_POINT_VIEWPORT = 0x00000000, + VK_STATE_BIND_POINT_RASTER = 0x00000001, + VK_STATE_BIND_POINT_COLOR_BLEND = 0x00000002, + VK_STATE_BIND_POINT_DEPTH_STENCIL = 0x00000003, - VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_VIEWPORT, - VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_DEPTH_STENCIL, - VK_NUM_STATE_BIND_POINT = (VK_STATE_BIND_POINT_END_RANGE - VK_STATE_BIND_POINT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkStateBindPoint) + VK_ENUM_RANGE(STATE_BIND_POINT, VIEWPORT, DEPTH_STENCIL) } VkStateBindPoint; typedef enum VkPrimitiveTopology_ { - VK_TOPOLOGY_POINT_LIST = 0x00000000, - VK_TOPOLOGY_LINE_LIST = 0x00000001, - VK_TOPOLOGY_LINE_STRIP = 0x00000002, - VK_TOPOLOGY_TRIANGLE_LIST = 0x00000003, - VK_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, - VK_TOPOLOGY_TRIANGLE_FAN = 0x00000005, - VK_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, - VK_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, - VK_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, - VK_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, - VK_TOPOLOGY_PATCH = 0x0000000a, - - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_TOPOLOGY_POINT_LIST, - VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_TOPOLOGY_PATCH, - VK_NUM_PRIMITIVE_TOPOLOGY = (VK_PRIMITIVE_TOPOLOGY_END_RANGE - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPrimitiveTopology) + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, + VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a, + + VK_ENUM_RANGE(PRIMITIVE_TOPOLOGY, POINT_LIST, PATCH) } VkPrimitiveTopology; typedef enum VkIndexType_ { - VK_INDEX_8 = 0x00000000, - VK_INDEX_16 = 0x00000001, - VK_INDEX_32 = 0x00000002, + VK_INDEX_TYPE_UINT8 = 0x00000000, + VK_INDEX_TYPE_UINT16 = 0x00000001, + VK_INDEX_TYPE_UINT32 = 0x00000002, - VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_8, - VK_INDEX_TYPE_END_RANGE = VK_INDEX_32, - VK_NUM_INDEX_TYPE = (VK_INDEX_TYPE_END_RANGE - VK_INDEX_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkIndexType) + VK_ENUM_RANGE(INDEX_TYPE, UINT8, UINT32) } VkIndexType; typedef enum VkTexFilter_ { - VK_TEX_FILTER_NEAREST = 0, - VK_TEX_FILTER_LINEAR = 1, + VK_TEX_FILTER_NEAREST = 0x00000000, + VK_TEX_FILTER_LINEAR = 0x00000001, - VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, - VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, - VK_NUM_TEX_FILTER = (VK_TEX_FILTER_END_RANGE - VK_TEX_FILTER_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkTexFilter) + VK_ENUM_RANGE(TEX_FILTER, NEAREST, LINEAR) } VkTexFilter; typedef enum VkTexMipmapMode_ { - VK_TEX_MIPMAP_BASE = 0, // Always choose base level - VK_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level - VK_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels + VK_TEX_MIPMAP_MODE_BASE = 0x00000000, // Always choose base level + VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001, // Choose nearest mip level + VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002, // Linear filter between mip levels - VK_TEX_MIPMAP_BEGIN_RANGE = VK_TEX_MIPMAP_BASE, - VK_TEX_MIPMAP_END_RANGE = VK_TEX_MIPMAP_LINEAR, - VK_NUM_TEX_MIPMAP = (VK_TEX_MIPMAP_END_RANGE - VK_TEX_MIPMAP_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkTexMipmapMode) + VK_ENUM_RANGE(TEX_MIPMAP_MODE, BASE, LINEAR) } VkTexMipmapMode; typedef enum VkTexAddress_ @@ -453,85 +379,64 @@ typedef enum VkTexAddress_ VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003, VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004, - VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, - VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, - VK_NUM_TEX_ADDRESS = (VK_TEX_ADDRESS_END_RANGE - VK_TEX_ADDRESS_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkTexAddress) + VK_ENUM_RANGE(TEX_ADDRESS, WRAP, CLAMP_BORDER) } VkTexAddress; -typedef enum VkCompareFunc_ +typedef enum VkCompareOp_ { - VK_COMPARE_NEVER = 0x00000000, - VK_COMPARE_LESS = 0x00000001, - VK_COMPARE_EQUAL = 0x00000002, - VK_COMPARE_LESS_EQUAL = 0x00000003, - VK_COMPARE_GREATER = 0x00000004, - VK_COMPARE_NOT_EQUAL = 0x00000005, - VK_COMPARE_GREATER_EQUAL = 0x00000006, - VK_COMPARE_ALWAYS = 0x00000007, + VK_COMPARE_OP_NEVER = 0x00000000, + VK_COMPARE_OP_LESS = 0x00000001, + VK_COMPARE_OP_EQUAL = 0x00000002, + VK_COMPARE_OP_LESS_EQUAL = 0x00000003, + VK_COMPARE_OP_GREATER = 0x00000004, + VK_COMPARE_OP_NOT_EQUAL = 0x00000005, + VK_COMPARE_OP_GREATER_EQUAL = 0x00000006, + VK_COMPARE_OP_ALWAYS = 0x00000007, - VK_COMPARE_FUNC_BEGIN_RANGE = VK_COMPARE_NEVER, - VK_COMPARE_FUNC_END_RANGE = VK_COMPARE_ALWAYS, - VK_NUM_COMPARE_FUNC = (VK_COMPARE_FUNC_END_RANGE - VK_COMPARE_FUNC_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkCompareFunc) -} VkCompareFunc; + VK_ENUM_RANGE(COMPARE_OP, NEVER, ALWAYS) +} VkCompareOp; typedef enum VkFillMode_ { - VK_FILL_POINTS = 0x00000000, - VK_FILL_WIREFRAME = 0x00000001, - VK_FILL_SOLID = 0x00000002, + VK_FILL_MODE_POINTS = 0x00000000, + VK_FILL_MODE_WIREFRAME = 0x00000001, + VK_FILL_MODE_SOLID = 0x00000002, - VK_FILL_MODE_BEGIN_RANGE = VK_FILL_POINTS, - VK_FILL_MODE_END_RANGE = VK_FILL_SOLID, - VK_NUM_FILL_MODE = (VK_FILL_MODE_END_RANGE - VK_FILL_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkFillMode) + VK_ENUM_RANGE(FILL_MODE, POINTS, SOLID) } VkFillMode; typedef enum VkCullMode_ { - VK_CULL_NONE = 0x00000000, - VK_CULL_FRONT = 0x00000001, - VK_CULL_BACK = 0x00000002, - VK_CULL_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_NONE = 0x00000000, + VK_CULL_MODE_FRONT = 0x00000001, + VK_CULL_MODE_BACK = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_BEGIN_RANGE = VK_CULL_NONE, - VK_CULL_MODE_END_RANGE = VK_CULL_FRONT_AND_BACK, - VK_NUM_CULL_MODE = (VK_CULL_MODE_END_RANGE - VK_CULL_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkCullMode) + VK_ENUM_RANGE(CULL_MODE, NONE, FRONT_AND_BACK) } VkCullMode; -typedef enum VkFaceOrientation_ +typedef enum VkFrontFace_ { VK_FRONT_FACE_CCW = 0x00000000, VK_FRONT_FACE_CW = 0x00000001, - VK_FACE_ORIENTATION_BEGIN_RANGE = VK_FRONT_FACE_CCW, - VK_FACE_ORIENTATION_END_RANGE = VK_FRONT_FACE_CW, - VK_NUM_FACE_ORIENTATION = (VK_FACE_ORIENTATION_END_RANGE - VK_FACE_ORIENTATION_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkFaceOrientation) -} VkFaceOrientation; + VK_ENUM_RANGE(FRONT_FACE, CCW, CW) +} VkFrontFace; -typedef enum VkProvokingVertexConvention_ +typedef enum VkProvokingVertex_ { VK_PROVOKING_VERTEX_FIRST = 0x00000000, VK_PROVOKING_VERTEX_LAST = 0x00000001, - VK_PROVOKING_VERTEX_BEGIN_RANGE = VK_PROVOKING_VERTEX_FIRST, - VK_PROVOKING_VERTEX_END_RANGE = VK_PROVOKING_VERTEX_LAST, - VK_NUM_PROVOKING_VERTEX_CONVENTION = (VK_PROVOKING_VERTEX_END_RANGE - VK_PROVOKING_VERTEX_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkProvokingVertexConvention) -} VkProvokingVertexConvention; + VK_ENUM_RANGE(PROVOKING_VERTEX, FIRST, LAST) +} VkProvokingVertex; typedef enum VkCoordinateOrigin_ { VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, - VK_COORDINATE_ORIGIN_BEGIN_RANGE = VK_COORDINATE_ORIGIN_UPPER_LEFT, - VK_COORDINATE_ORIGIN_END_RANGE = VK_COORDINATE_ORIGIN_LOWER_LEFT, - VK_NUM_COORDINATE_ORIGIN = (VK_COORDINATE_ORIGIN_END_RANGE - VK_COORDINATE_ORIGIN_END_RANGE + 1), - VK_MAX_ENUM(VkCoordinateOrigin) + VK_ENUM_RANGE(COORDINATE_ORIGIN, UPPER_LEFT, LOWER_LEFT) } VkCoordinateOrigin; typedef enum VkDepthMode_ @@ -539,10 +444,7 @@ typedef enum VkDepthMode_ VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000, VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001, - VK_DEPTH_MODE_BEGIN_RANGE = VK_DEPTH_MODE_ZERO_TO_ONE, - VK_DEPTH_MODE_END_RANGE = VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE, - VK_NUM_DEPTH_MODE = (VK_DEPTH_MODE_END_RANGE - VK_DEPTH_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkDepthMode) + VK_ENUM_RANGE(DEPTH_MODE, ZERO_TO_ONE, NEGATIVE_ONE_TO_ONE) } VkDepthMode; typedef enum VkBlend_ @@ -567,25 +469,19 @@ typedef enum VkBlend_ VK_BLEND_SRC1_ALPHA = 0x00000011, VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012, - VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, - VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, - VK_NUM_BLEND = (VK_BLEND_END_RANGE - VK_BLEND_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkBlend) + VK_ENUM_RANGE(BLEND, ZERO, ONE_MINUS_SRC1_ALPHA) } VkBlend; -typedef enum VkBlendFunc_ +typedef enum VkBlendOp_ { - VK_BLEND_FUNC_ADD = 0x00000000, - VK_BLEND_FUNC_SUBTRACT = 0x00000001, - VK_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002, - VK_BLEND_FUNC_MIN = 0x00000003, - VK_BLEND_FUNC_MAX = 0x00000004, + VK_BLEND_OP_ADD = 0x00000000, + VK_BLEND_OP_SUBTRACT = 0x00000001, + VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002, + VK_BLEND_OP_MIN = 0x00000003, + VK_BLEND_OP_MAX = 0x00000004, - VK_BLEND_FUNC_BEGIN_RANGE = VK_BLEND_FUNC_ADD, - VK_BLEND_FUNC_END_RANGE = VK_BLEND_FUNC_MAX, - VK_NUM_BLEND_FUNC = (VK_BLEND_FUNC_END_RANGE - VK_BLEND_FUNC_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkBlendFunc) -} VkBlendFunc; + VK_ENUM_RANGE(BLEND_OP, ADD, MAX) +} VkBlendOp; typedef enum VkStencilOp_ { @@ -598,10 +494,7 @@ typedef enum VkStencilOp_ VK_STENCIL_OP_INC_WRAP = 0x00000006, VK_STENCIL_OP_DEC_WRAP = 0x00000007, - VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, - VK_NUM_STENCIL_OP = (VK_STENCIL_OP_END_RANGE - VK_STENCIL_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkStencilOp) + VK_ENUM_RANGE(STENCIL_OP, KEEP, DEC_WRAP) } VkStencilOp; typedef enum VkLogicOp_ @@ -623,52 +516,41 @@ typedef enum VkLogicOp_ VK_LOGIC_OP_NAND = 0x0000000e, VK_LOGIC_OP_SET = 0x0000000f, - VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_COPY, - VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, - VK_NUM_LOGIC_OP = (VK_LOGIC_OP_END_RANGE - VK_LOGIC_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkLogicOp) + VK_ENUM_RANGE(LOGIC_OP, COPY, SET) } VkLogicOp; typedef enum VkSystemAllocType_ { - VK_SYSTEM_ALLOC_API_OBJECT = 0x00000000, - VK_SYSTEM_ALLOC_INTERNAL = 0x00000001, - VK_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002, - VK_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003, - VK_SYSTEM_ALLOC_DEBUG = 0x00000004, + VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000, + VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003, + VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004, - VK_SYSTEM_ALLOC_BEGIN_RANGE = VK_SYSTEM_ALLOC_API_OBJECT, - VK_SYSTEM_ALLOC_END_RANGE = VK_SYSTEM_ALLOC_DEBUG, - VK_NUM_SYSTEM_ALLOC_TYPE = (VK_SYSTEM_ALLOC_END_RANGE - VK_SYSTEM_ALLOC_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkSystemAllocType) + VK_ENUM_RANGE(SYSTEM_ALLOC_TYPE, API_OBJECT, DEBUG) } VkSystemAllocType; -typedef enum VkPhysicalGpuType_ +typedef enum VkPhysicalDeviceType_ { - VK_GPU_TYPE_OTHER = 0x00000000, - VK_GPU_TYPE_INTEGRATED = 0x00000001, - VK_GPU_TYPE_DISCRETE = 0x00000002, - VK_GPU_TYPE_VIRTUAL = 0x00000003, + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003, + VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004, - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE = VK_GPU_TYPE_OTHER, - VK_PHYSICAL_GPU_TYPE_END_RANGE = VK_GPU_TYPE_VIRTUAL, - VK_NUM_PHYSICAL_GPU_TYPE = (VK_PHYSICAL_GPU_TYPE_END_RANGE - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPhysicalGpuType) -} VkPhysicalGpuType; + VK_ENUM_RANGE(PHYSICAL_DEVICE_TYPE, OTHER, CPU) +} VkPhysicalDeviceType; -typedef enum VkPhysicalGpuInfoType_ +typedef enum VkPhysicalDeviceInfoType_ { - // Info type for vkGetGpuInfo() - VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000, - VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001, - VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002, - VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003, + // Info type for vkGetPhysicalDeviceInfo() + VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES = 0x00000000, + VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE = 0x00000001, + VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES = 0x00000002, + VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES = 0x00000003, - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, - VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, - VK_NUM_INFO_TYPE_PHYSICAL_GPU = (VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPhysicalGpuInfoType) -} VkPhysicalGpuInfoType; + VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE, PROPERTIES, MEMORY_PROPERTIES) +} VkPhysicalDeviceInfoType; typedef enum VkExtensionInfoType_ { @@ -682,37 +564,290 @@ typedef enum VkExtensionInfoType_ typedef enum VkFormatInfoType_ { // Info type for vkGetFormatInfo() - VK_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000, + VK_FORMAT_INFO_TYPE_PROPERTIES = 0x00000000, - VK_INFO_TYPE_FORMAT_BEGIN_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, - VK_INFO_TYPE_FORMAT_END_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, - VK_NUM_INFO_TYPE_FORMAT = (VK_INFO_TYPE_FORMAT_END_RANGE - VK_INFO_TYPE_FORMAT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkFormatInfoType) + VK_ENUM_RANGE(FORMAT_INFO_TYPE, PROPERTIES, PROPERTIES) } VkFormatInfoType; typedef enum VkSubresourceInfoType_ { // Info type for vkGetImageSubresourceInfo() - VK_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000, + VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000, - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, - VK_INFO_TYPE_SUBRESOURCE_END_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, - VK_NUM_INFO_TYPE_SUBRESOURCE = (VK_INFO_TYPE_SUBRESOURCE_END_RANGE - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkSubresourceInfoType) + VK_ENUM_RANGE(SUBRESOURCE_INFO_TYPE, LAYOUT, LAYOUT) } VkSubresourceInfoType; typedef enum VkObjectInfoType_ { // Info type for vkGetObjectInfo() - VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, - VK_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001, + VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, + VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001, - VK_INFO_TYPE_BEGIN_RANGE = VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, - VK_INFO_TYPE_END_RANGE = VK_INFO_TYPE_MEMORY_REQUIREMENTS, - VK_NUM_INFO_TYPE = (VK_INFO_TYPE_END_RANGE - VK_INFO_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkObjectInfoType) + VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_ALLOCATION_COUNT, MEMORY_REQUIREMENTS) } VkObjectInfoType; +typedef enum VkVertexInputStepRate_ +{ + VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, + VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, + VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional + + VK_ENUM_RANGE(VERTEX_INPUT_STEP_RATE, VERTEX, DRAW) +} VkVertexInputStepRate; + +// ------------------------------------------------------------------------------------------------ +// Vulkan format definitions +typedef enum VkFormat_ +{ + VK_FORMAT_UNDEFINED = 0x00000000, + VK_FORMAT_R4G4_UNORM = 0x00000001, + VK_FORMAT_R4G4_USCALED = 0x00000002, + VK_FORMAT_R4G4B4A4_UNORM = 0x00000003, + VK_FORMAT_R4G4B4A4_USCALED = 0x00000004, + VK_FORMAT_R5G6B5_UNORM = 0x00000005, + VK_FORMAT_R5G6B5_USCALED = 0x00000006, + VK_FORMAT_R5G5B5A1_UNORM = 0x00000007, + VK_FORMAT_R5G5B5A1_USCALED = 0x00000008, + VK_FORMAT_R8_UNORM = 0x00000009, + VK_FORMAT_R8_SNORM = 0x0000000A, + VK_FORMAT_R8_USCALED = 0x0000000B, + VK_FORMAT_R8_SSCALED = 0x0000000C, + VK_FORMAT_R8_UINT = 0x0000000D, + VK_FORMAT_R8_SINT = 0x0000000E, + VK_FORMAT_R8_SRGB = 0x0000000F, + VK_FORMAT_R8G8_UNORM = 0x00000010, + VK_FORMAT_R8G8_SNORM = 0x00000011, + VK_FORMAT_R8G8_USCALED = 0x00000012, + VK_FORMAT_R8G8_SSCALED = 0x00000013, + VK_FORMAT_R8G8_UINT = 0x00000014, + VK_FORMAT_R8G8_SINT = 0x00000015, + VK_FORMAT_R8G8_SRGB = 0x00000016, + VK_FORMAT_R8G8B8_UNORM = 0x00000017, + VK_FORMAT_R8G8B8_SNORM = 0x00000018, + VK_FORMAT_R8G8B8_USCALED = 0x00000019, + VK_FORMAT_R8G8B8_SSCALED = 0x0000001A, + VK_FORMAT_R8G8B8_UINT = 0x0000001B, + VK_FORMAT_R8G8B8_SINT = 0x0000001C, + VK_FORMAT_R8G8B8_SRGB = 0x0000001D, + VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E, + VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F, + VK_FORMAT_R8G8B8A8_USCALED = 0x00000020, + VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021, + VK_FORMAT_R8G8B8A8_UINT = 0x00000022, + VK_FORMAT_R8G8B8A8_SINT = 0x00000023, + VK_FORMAT_R8G8B8A8_SRGB = 0x00000024, + VK_FORMAT_R10G10B10A2_UNORM = 0x00000025, + VK_FORMAT_R10G10B10A2_SNORM = 0x00000026, + VK_FORMAT_R10G10B10A2_USCALED = 0x00000027, + VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028, + VK_FORMAT_R10G10B10A2_UINT = 0x00000029, + VK_FORMAT_R10G10B10A2_SINT = 0x0000002A, + VK_FORMAT_R16_UNORM = 0x0000002B, + VK_FORMAT_R16_SNORM = 0x0000002C, + VK_FORMAT_R16_USCALED = 0x0000002D, + VK_FORMAT_R16_SSCALED = 0x0000002E, + VK_FORMAT_R16_UINT = 0x0000002F, + VK_FORMAT_R16_SINT = 0x00000030, + VK_FORMAT_R16_SFLOAT = 0x00000031, + VK_FORMAT_R16G16_UNORM = 0x00000032, + VK_FORMAT_R16G16_SNORM = 0x00000033, + VK_FORMAT_R16G16_USCALED = 0x00000034, + VK_FORMAT_R16G16_SSCALED = 0x00000035, + VK_FORMAT_R16G16_UINT = 0x00000036, + VK_FORMAT_R16G16_SINT = 0x00000037, + VK_FORMAT_R16G16_SFLOAT = 0x00000038, + VK_FORMAT_R16G16B16_UNORM = 0x00000039, + VK_FORMAT_R16G16B16_SNORM = 0x0000003A, + VK_FORMAT_R16G16B16_USCALED = 0x0000003B, + VK_FORMAT_R16G16B16_SSCALED = 0x0000003C, + VK_FORMAT_R16G16B16_UINT = 0x0000003D, + VK_FORMAT_R16G16B16_SINT = 0x0000003E, + VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F, + VK_FORMAT_R16G16B16A16_UNORM = 0x00000040, + VK_FORMAT_R16G16B16A16_SNORM = 0x00000041, + VK_FORMAT_R16G16B16A16_USCALED = 0x00000042, + VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043, + VK_FORMAT_R16G16B16A16_UINT = 0x00000044, + VK_FORMAT_R16G16B16A16_SINT = 0x00000045, + VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046, + VK_FORMAT_R32_UINT = 0x00000047, + VK_FORMAT_R32_SINT = 0x00000048, + VK_FORMAT_R32_SFLOAT = 0x00000049, + VK_FORMAT_R32G32_UINT = 0x0000004A, + VK_FORMAT_R32G32_SINT = 0x0000004B, + VK_FORMAT_R32G32_SFLOAT = 0x0000004C, + VK_FORMAT_R32G32B32_UINT = 0x0000004D, + VK_FORMAT_R32G32B32_SINT = 0x0000004E, + VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F, + VK_FORMAT_R32G32B32A32_UINT = 0x00000050, + VK_FORMAT_R32G32B32A32_SINT = 0x00000051, + VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052, + VK_FORMAT_R64_SFLOAT = 0x00000053, + VK_FORMAT_R64G64_SFLOAT = 0x00000054, + VK_FORMAT_R64G64B64_SFLOAT = 0x00000055, + VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056, + VK_FORMAT_R11G11B10_UFLOAT = 0x00000057, + VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058, + VK_FORMAT_D16_UNORM = 0x00000059, + VK_FORMAT_D24_UNORM = 0x0000005A, + VK_FORMAT_D32_SFLOAT = 0x0000005B, + VK_FORMAT_S8_UINT = 0x0000005C, + VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D, + VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E, + VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F, + VK_FORMAT_BC1_RGB_UNORM = 0x00000060, + VK_FORMAT_BC1_RGB_SRGB = 0x00000061, + VK_FORMAT_BC1_RGBA_UNORM = 0x00000062, + VK_FORMAT_BC1_RGBA_SRGB = 0x00000063, + VK_FORMAT_BC2_UNORM = 0x00000064, + VK_FORMAT_BC2_SRGB = 0x00000065, + VK_FORMAT_BC3_UNORM = 0x00000066, + VK_FORMAT_BC3_SRGB = 0x00000067, + VK_FORMAT_BC4_UNORM = 0x00000068, + VK_FORMAT_BC4_SNORM = 0x00000069, + VK_FORMAT_BC5_UNORM = 0x0000006A, + VK_FORMAT_BC5_SNORM = 0x0000006B, + VK_FORMAT_BC6H_UFLOAT = 0x0000006C, + VK_FORMAT_BC6H_SFLOAT = 0x0000006D, + VK_FORMAT_BC7_UNORM = 0x0000006E, + VK_FORMAT_BC7_SRGB = 0x0000006F, + VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070, + VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071, + VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072, + VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073, + VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074, + VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075, + VK_FORMAT_EAC_R11_UNORM = 0x00000076, + VK_FORMAT_EAC_R11_SNORM = 0x00000077, + VK_FORMAT_EAC_R11G11_UNORM = 0x00000078, + VK_FORMAT_EAC_R11G11_SNORM = 0x00000079, + VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A, + VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B, + VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C, + VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D, + VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E, + VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F, + VK_FORMAT_ASTC_6x5_UNORM = 0x00000080, + VK_FORMAT_ASTC_6x5_SRGB = 0x00000081, + VK_FORMAT_ASTC_6x6_UNORM = 0x00000082, + VK_FORMAT_ASTC_6x6_SRGB = 0x00000083, + VK_FORMAT_ASTC_8x5_UNORM = 0x00000084, + VK_FORMAT_ASTC_8x5_SRGB = 0x00000085, + VK_FORMAT_ASTC_8x6_UNORM = 0x00000086, + VK_FORMAT_ASTC_8x6_SRGB = 0x00000087, + VK_FORMAT_ASTC_8x8_UNORM = 0x00000088, + VK_FORMAT_ASTC_8x8_SRGB = 0x00000089, + VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A, + VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B, + VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C, + VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D, + VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E, + VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F, + VK_FORMAT_ASTC_10x10_UNORM = 0x00000090, + VK_FORMAT_ASTC_10x10_SRGB = 0x00000091, + VK_FORMAT_ASTC_12x10_UNORM = 0x00000092, + VK_FORMAT_ASTC_12x10_SRGB = 0x00000093, + VK_FORMAT_ASTC_12x12_UNORM = 0x00000094, + VK_FORMAT_ASTC_12x12_SRGB = 0x00000095, + VK_FORMAT_B4G4R4A4_UNORM = 0x00000096, + VK_FORMAT_B5G5R5A1_UNORM = 0x00000097, + VK_FORMAT_B5G6R5_UNORM = 0x00000098, + VK_FORMAT_B5G6R5_USCALED = 0x00000099, + VK_FORMAT_B8G8R8_UNORM = 0x0000009A, + VK_FORMAT_B8G8R8_SNORM = 0x0000009B, + VK_FORMAT_B8G8R8_USCALED = 0x0000009C, + VK_FORMAT_B8G8R8_SSCALED = 0x0000009D, + VK_FORMAT_B8G8R8_UINT = 0x0000009E, + VK_FORMAT_B8G8R8_SINT = 0x0000009F, + VK_FORMAT_B8G8R8_SRGB = 0x000000A0, + VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1, + VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2, + VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3, + VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4, + VK_FORMAT_B8G8R8A8_UINT = 0x000000A5, + VK_FORMAT_B8G8R8A8_SINT = 0x000000A6, + VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7, + VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8, + VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9, + VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA, + VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB, + VK_FORMAT_B10G10R10A2_UINT = 0x000000AC, + VK_FORMAT_B10G10R10A2_SINT = 0x000000AD, + + VK_ENUM_RANGE(FORMAT, UNDEFINED, B10G10R10A2_SINT) +} VkFormat; + +// Shader stage enumerant +typedef enum VkShaderStage_ +{ + VK_SHADER_STAGE_VERTEX = 0, + VK_SHADER_STAGE_TESS_CONTROL = 1, + VK_SHADER_STAGE_TESS_EVALUATION = 2, + VK_SHADER_STAGE_GEOMETRY = 3, + VK_SHADER_STAGE_FRAGMENT = 4, + VK_SHADER_STAGE_COMPUTE = 5, + + VK_ENUM_RANGE(SHADER_STAGE, VERTEX, COMPUTE) +} VkShaderStage; + +// Structure type enumerant +typedef enum VkStructureType_ +{ + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, + VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 3, + VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 4, + VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 5, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 6, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 7, + VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 22, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 34, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 35, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 38, + VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 39, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 40, + VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 41, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 42, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 45, + VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 46, + VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 47, + VK_STRUCTURE_TYPE_UPDATE_IMAGES = 48, + VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 49, + VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 50, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 51, + + VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, INSTANCE_CREATE_INFO) +} VkStructureType; // ------------------------------------------------------------------------------------------------ // Error and return codes @@ -731,8 +866,8 @@ typedef enum VkResult_ VK_ERROR_UNKNOWN = -(0x00000001), VK_ERROR_UNAVAILABLE = -(0x00000002), VK_ERROR_INITIALIZATION_FAILED = -(0x00000003), - VK_ERROR_OUT_OF_MEMORY = -(0x00000004), - VK_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005), + VK_ERROR_OUT_OF_HOST_MEMORY = -(0x00000004), + VK_ERROR_OUT_OF_DEVICE_MEMORY = -(0x00000005), VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006), VK_ERROR_DEVICE_LOST = -(0x00000007), VK_ERROR_INVALID_POINTER = -(0x00000008), @@ -762,485 +897,245 @@ typedef enum VkResult_ VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020), VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021), VK_ERROR_NOT_SHAREABLE = -(0x00000022), - VK_MAX_ENUM(VkResult) -} VkResult; - -// ------------------------------------------------------------------------------------------------ -// Vulkan format definitions - -typedef enum VkVertexInputStepRate_ -{ - VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, - VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, - VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, - VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_DRAW, - VK_NUM_VERTEX_INPUT_STEP_RATE = (VK_VERTEX_INPUT_STEP_RATE_END_RANGE - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkVertexInputStepRate) -} VkVertexInputStepRate; - -typedef enum VkFormat_ -{ - VK_FMT_UNDEFINED = 0x00000000, - VK_FMT_R4G4_UNORM = 0x00000001, - VK_FMT_R4G4_USCALED = 0x00000002, - VK_FMT_R4G4B4A4_UNORM = 0x00000003, - VK_FMT_R4G4B4A4_USCALED = 0x00000004, - VK_FMT_R5G6B5_UNORM = 0x00000005, - VK_FMT_R5G6B5_USCALED = 0x00000006, - VK_FMT_R5G5B5A1_UNORM = 0x00000007, - VK_FMT_R5G5B5A1_USCALED = 0x00000008, - VK_FMT_R8_UNORM = 0x00000009, - VK_FMT_R8_SNORM = 0x0000000A, - VK_FMT_R8_USCALED = 0x0000000B, - VK_FMT_R8_SSCALED = 0x0000000C, - VK_FMT_R8_UINT = 0x0000000D, - VK_FMT_R8_SINT = 0x0000000E, - VK_FMT_R8_SRGB = 0x0000000F, - VK_FMT_R8G8_UNORM = 0x00000010, - VK_FMT_R8G8_SNORM = 0x00000011, - VK_FMT_R8G8_USCALED = 0x00000012, - VK_FMT_R8G8_SSCALED = 0x00000013, - VK_FMT_R8G8_UINT = 0x00000014, - VK_FMT_R8G8_SINT = 0x00000015, - VK_FMT_R8G8_SRGB = 0x00000016, - VK_FMT_R8G8B8_UNORM = 0x00000017, - VK_FMT_R8G8B8_SNORM = 0x00000018, - VK_FMT_R8G8B8_USCALED = 0x00000019, - VK_FMT_R8G8B8_SSCALED = 0x0000001A, - VK_FMT_R8G8B8_UINT = 0x0000001B, - VK_FMT_R8G8B8_SINT = 0x0000001C, - VK_FMT_R8G8B8_SRGB = 0x0000001D, - VK_FMT_R8G8B8A8_UNORM = 0x0000001E, - VK_FMT_R8G8B8A8_SNORM = 0x0000001F, - VK_FMT_R8G8B8A8_USCALED = 0x00000020, - VK_FMT_R8G8B8A8_SSCALED = 0x00000021, - VK_FMT_R8G8B8A8_UINT = 0x00000022, - VK_FMT_R8G8B8A8_SINT = 0x00000023, - VK_FMT_R8G8B8A8_SRGB = 0x00000024, - VK_FMT_R10G10B10A2_UNORM = 0x00000025, - VK_FMT_R10G10B10A2_SNORM = 0x00000026, - VK_FMT_R10G10B10A2_USCALED = 0x00000027, - VK_FMT_R10G10B10A2_SSCALED = 0x00000028, - VK_FMT_R10G10B10A2_UINT = 0x00000029, - VK_FMT_R10G10B10A2_SINT = 0x0000002A, - VK_FMT_R16_UNORM = 0x0000002B, - VK_FMT_R16_SNORM = 0x0000002C, - VK_FMT_R16_USCALED = 0x0000002D, - VK_FMT_R16_SSCALED = 0x0000002E, - VK_FMT_R16_UINT = 0x0000002F, - VK_FMT_R16_SINT = 0x00000030, - VK_FMT_R16_SFLOAT = 0x00000031, - VK_FMT_R16G16_UNORM = 0x00000032, - VK_FMT_R16G16_SNORM = 0x00000033, - VK_FMT_R16G16_USCALED = 0x00000034, - VK_FMT_R16G16_SSCALED = 0x00000035, - VK_FMT_R16G16_UINT = 0x00000036, - VK_FMT_R16G16_SINT = 0x00000037, - VK_FMT_R16G16_SFLOAT = 0x00000038, - VK_FMT_R16G16B16_UNORM = 0x00000039, - VK_FMT_R16G16B16_SNORM = 0x0000003A, - VK_FMT_R16G16B16_USCALED = 0x0000003B, - VK_FMT_R16G16B16_SSCALED = 0x0000003C, - VK_FMT_R16G16B16_UINT = 0x0000003D, - VK_FMT_R16G16B16_SINT = 0x0000003E, - VK_FMT_R16G16B16_SFLOAT = 0x0000003F, - VK_FMT_R16G16B16A16_UNORM = 0x00000040, - VK_FMT_R16G16B16A16_SNORM = 0x00000041, - VK_FMT_R16G16B16A16_USCALED = 0x00000042, - VK_FMT_R16G16B16A16_SSCALED = 0x00000043, - VK_FMT_R16G16B16A16_UINT = 0x00000044, - VK_FMT_R16G16B16A16_SINT = 0x00000045, - VK_FMT_R16G16B16A16_SFLOAT = 0x00000046, - VK_FMT_R32_UINT = 0x00000047, - VK_FMT_R32_SINT = 0x00000048, - VK_FMT_R32_SFLOAT = 0x00000049, - VK_FMT_R32G32_UINT = 0x0000004A, - VK_FMT_R32G32_SINT = 0x0000004B, - VK_FMT_R32G32_SFLOAT = 0x0000004C, - VK_FMT_R32G32B32_UINT = 0x0000004D, - VK_FMT_R32G32B32_SINT = 0x0000004E, - VK_FMT_R32G32B32_SFLOAT = 0x0000004F, - VK_FMT_R32G32B32A32_UINT = 0x00000050, - VK_FMT_R32G32B32A32_SINT = 0x00000051, - VK_FMT_R32G32B32A32_SFLOAT = 0x00000052, - VK_FMT_R64_SFLOAT = 0x00000053, - VK_FMT_R64G64_SFLOAT = 0x00000054, - VK_FMT_R64G64B64_SFLOAT = 0x00000055, - VK_FMT_R64G64B64A64_SFLOAT = 0x00000056, - VK_FMT_R11G11B10_UFLOAT = 0x00000057, - VK_FMT_R9G9B9E5_UFLOAT = 0x00000058, - VK_FMT_D16_UNORM = 0x00000059, - VK_FMT_D24_UNORM = 0x0000005A, - VK_FMT_D32_SFLOAT = 0x0000005B, - VK_FMT_S8_UINT = 0x0000005C, - VK_FMT_D16_UNORM_S8_UINT = 0x0000005D, - VK_FMT_D24_UNORM_S8_UINT = 0x0000005E, - VK_FMT_D32_SFLOAT_S8_UINT = 0x0000005F, - VK_FMT_BC1_RGB_UNORM = 0x00000060, - VK_FMT_BC1_RGB_SRGB = 0x00000061, - VK_FMT_BC1_RGBA_UNORM = 0x00000062, - VK_FMT_BC1_RGBA_SRGB = 0x00000063, - VK_FMT_BC2_UNORM = 0x00000064, - VK_FMT_BC2_SRGB = 0x00000065, - VK_FMT_BC3_UNORM = 0x00000066, - VK_FMT_BC3_SRGB = 0x00000067, - VK_FMT_BC4_UNORM = 0x00000068, - VK_FMT_BC4_SNORM = 0x00000069, - VK_FMT_BC5_UNORM = 0x0000006A, - VK_FMT_BC5_SNORM = 0x0000006B, - VK_FMT_BC6H_UFLOAT = 0x0000006C, - VK_FMT_BC6H_SFLOAT = 0x0000006D, - VK_FMT_BC7_UNORM = 0x0000006E, - VK_FMT_BC7_SRGB = 0x0000006F, - VK_FMT_ETC2_R8G8B8_UNORM = 0x00000070, - VK_FMT_ETC2_R8G8B8_SRGB = 0x00000071, - VK_FMT_ETC2_R8G8B8A1_UNORM = 0x00000072, - VK_FMT_ETC2_R8G8B8A1_SRGB = 0x00000073, - VK_FMT_ETC2_R8G8B8A8_UNORM = 0x00000074, - VK_FMT_ETC2_R8G8B8A8_SRGB = 0x00000075, - VK_FMT_EAC_R11_UNORM = 0x00000076, - VK_FMT_EAC_R11_SNORM = 0x00000077, - VK_FMT_EAC_R11G11_UNORM = 0x00000078, - VK_FMT_EAC_R11G11_SNORM = 0x00000079, - VK_FMT_ASTC_4x4_UNORM = 0x0000007A, - VK_FMT_ASTC_4x4_SRGB = 0x0000007B, - VK_FMT_ASTC_5x4_UNORM = 0x0000007C, - VK_FMT_ASTC_5x4_SRGB = 0x0000007D, - VK_FMT_ASTC_5x5_UNORM = 0x0000007E, - VK_FMT_ASTC_5x5_SRGB = 0x0000007F, - VK_FMT_ASTC_6x5_UNORM = 0x00000080, - VK_FMT_ASTC_6x5_SRGB = 0x00000081, - VK_FMT_ASTC_6x6_UNORM = 0x00000082, - VK_FMT_ASTC_6x6_SRGB = 0x00000083, - VK_FMT_ASTC_8x5_UNORM = 0x00000084, - VK_FMT_ASTC_8x5_SRGB = 0x00000085, - VK_FMT_ASTC_8x6_UNORM = 0x00000086, - VK_FMT_ASTC_8x6_SRGB = 0x00000087, - VK_FMT_ASTC_8x8_UNORM = 0x00000088, - VK_FMT_ASTC_8x8_SRGB = 0x00000089, - VK_FMT_ASTC_10x5_UNORM = 0x0000008A, - VK_FMT_ASTC_10x5_SRGB = 0x0000008B, - VK_FMT_ASTC_10x6_UNORM = 0x0000008C, - VK_FMT_ASTC_10x6_SRGB = 0x0000008D, - VK_FMT_ASTC_10x8_UNORM = 0x0000008E, - VK_FMT_ASTC_10x8_SRGB = 0x0000008F, - VK_FMT_ASTC_10x10_UNORM = 0x00000090, - VK_FMT_ASTC_10x10_SRGB = 0x00000091, - VK_FMT_ASTC_12x10_UNORM = 0x00000092, - VK_FMT_ASTC_12x10_SRGB = 0x00000093, - VK_FMT_ASTC_12x12_UNORM = 0x00000094, - VK_FMT_ASTC_12x12_SRGB = 0x00000095, - VK_FMT_B4G4R4A4_UNORM = 0x00000096, - VK_FMT_B5G5R5A1_UNORM = 0x00000097, - VK_FMT_B5G6R5_UNORM = 0x00000098, - VK_FMT_B5G6R5_USCALED = 0x00000099, - VK_FMT_B8G8R8_UNORM = 0x0000009A, - VK_FMT_B8G8R8_SNORM = 0x0000009B, - VK_FMT_B8G8R8_USCALED = 0x0000009C, - VK_FMT_B8G8R8_SSCALED = 0x0000009D, - VK_FMT_B8G8R8_UINT = 0x0000009E, - VK_FMT_B8G8R8_SINT = 0x0000009F, - VK_FMT_B8G8R8_SRGB = 0x000000A0, - VK_FMT_B8G8R8A8_UNORM = 0x000000A1, - VK_FMT_B8G8R8A8_SNORM = 0x000000A2, - VK_FMT_B8G8R8A8_USCALED = 0x000000A3, - VK_FMT_B8G8R8A8_SSCALED = 0x000000A4, - VK_FMT_B8G8R8A8_UINT = 0x000000A5, - VK_FMT_B8G8R8A8_SINT = 0x000000A6, - VK_FMT_B8G8R8A8_SRGB = 0x000000A7, - VK_FMT_B10G10R10A2_UNORM = 0x000000A8, - VK_FMT_B10G10R10A2_SNORM = 0x000000A9, - VK_FMT_B10G10R10A2_USCALED = 0x000000AA, - VK_FMT_B10G10R10A2_SSCALED = 0x000000AB, - VK_FMT_B10G10R10A2_UINT = 0x000000AC, - VK_FMT_B10G10R10A2_SINT = 0x000000AD, - - VK_FMT_BEGIN_RANGE = VK_FMT_UNDEFINED, - VK_FMT_END_RANGE = VK_FMT_B10G10R10A2_SINT, - VK_NUM_FMT = (VK_FMT_END_RANGE - VK_FMT_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkFormat) -} VkFormat; - -// Shader stage enumerant -typedef enum VkPipelineShaderStage_ -{ - VK_SHADER_STAGE_VERTEX = 0, - VK_SHADER_STAGE_TESS_CONTROL = 1, - VK_SHADER_STAGE_TESS_EVALUATION = 2, - VK_SHADER_STAGE_GEOMETRY = 3, - VK_SHADER_STAGE_FRAGMENT = 4, - VK_SHADER_STAGE_COMPUTE = 5, - - VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, - VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, - VK_NUM_SHADER_STAGE = (VK_SHADER_STAGE_END_RANGE - VK_SHADER_STAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkPipelineShaderStage) -} VkPipelineShaderStage; - -typedef enum VkShaderStageFlags_ -{ - VK_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_FLAGS_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FLAGS_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020, - - VK_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF, - VK_MAX_ENUM(VkShaderStageFlags) -} VkShaderStageFlags; - -// Structure type enumerant -typedef enum VkStructureType_ -{ - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4, - VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5, - VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7, - VK_STRUCTURE_TYPE_EVENT_WAIT_INFO = 8, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34, - VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 40, - VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42, - VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43, - VK_STRUCTURE_TYPE_PIPELINE_BARRIER = 44, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 49, - VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 50, - VK_STRUCTURE_TYPE_UPDATE_IMAGES = 51, - VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 52, - VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 53, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 54, - - VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - - VK_NUM_STRUCTURE_TYPE = (VK_STRUCTURE_TYPE_END_RANGE - VK_STRUCTURE_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkStructureType) -} VkStructureType; + VK_MAX_ENUM(RESULT) +} VkResult; // ------------------------------------------------------------------------------------------------ // Flags // Device creation flags -typedef enum VkDeviceCreateFlags_ +typedef VkFlags VkDeviceCreateFlags; +typedef enum VkDeviceCreateFlagBits_ { - VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, - VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002, - VK_MAX_ENUM(VkDeviceCreateFlags) -} VkDeviceCreateFlags; + VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0), + VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1), +} VkDeviceCreateFlagBits; // Queue capabilities -typedef enum VkQueueFlags_ -{ - 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_MEMMGR_BIT = 0x00000008, // Queue supports memory management operations - VK_QUEUE_EXTENDED_BIT = 0x40000000, // Extended queue - VK_MAX_ENUM(VkQueueFlags) -} VkQueueFlags; - -// memory properties passed into vkAllocMemory(). -typedef enum VkMemoryPropertyFlags_ -{ - VK_MEMORY_PROPERTY_GPU_ONLY = 0x00000000, // If not set, then allocate memory on device (GPU) - VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT = 0x00000001, - VK_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT = 0x00000002, - VK_MEMORY_PROPERTY_CPU_UNCACHED_BIT = 0x00000004, - VK_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_PREFER_CPU_LOCAL = 0x00000010, // all else being equal, prefer CPU access - VK_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000020, - VK_MAX_ENUM(VkMemoryPropertyFlags) -} VkMemoryPropertyFlags; - -// Buffer and buffer allocation usage flags -typedef enum VkBufferUsageFlags_ -{ - VK_BUFFER_USAGE_GENERAL = 0x00000000, // No special usage - VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, // Can be used as a source of transfer operations - VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, // Can be used as a destination of transfer operations - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, // Can be used as TBO - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, // Can be used as IBO - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, // Can be used as UBO - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, // Can be used as SSBO - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, // Can be used as source of fixed function index fetch (index buffer) - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, // Can be used as source of fixed function vertex fetch (VBO) - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) - VK_MAX_ENUM(VkBufferUsageFlags) -} VkBufferUsageFlags; - -// Buffer flags -typedef enum VkBufferCreateFlags_ -{ - VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002, - VK_MAX_ENUM(VkBufferCreateFlags) -} VkBufferCreateFlags; - -typedef enum VkBufferViewType_ -{ - VK_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (UBO, SSBO) - VK_BUFFER_VIEW_FORMATTED = 0x00000001, // Buffer with format (TBO, IBO) - - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_RAW, - VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_FORMATTED, - VK_NUM_BUFFER_VIEW_TYPE = (VK_BUFFER_VIEW_TYPE_END_RANGE - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(VkBufferViewType) -} VkBufferViewType; - -// Image and image allocation usage flags -typedef enum VkImageUsageFlags_ -{ - VK_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage - VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, // Can be used as a source of transfer operations - VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, // Can be used as a destination of transfer operations - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, // Can be used as storage image (STORAGE_IMAGE descriptor type) - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, // Can be used as framebuffer color attachment - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020, // Can be used as framebuffer depth/stencil attachment - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, // Image data not needed outside of rendering - VK_MAX_ENUM(VkImageUsageFlags) -} VkImageUsageFlags; - -// Image flags -typedef enum VkImageCreateFlags_ -{ - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001, - VK_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002, - VK_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004, - VK_IMAGE_CREATE_SPARSE_BIT = 0x00000008, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, // Allows creating image views with cube type from the created image - VK_MAX_ENUM(VkImageCreateFlags) -} VkImageCreateFlags; +typedef VkFlags VkQueueFlags; +typedef enum VkQueueFlagBits_ +{ + VK_QUEUE_GRAPHICS_BIT = VK_BIT(0), // Queue supports graphics operations + VK_QUEUE_COMPUTE_BIT = VK_BIT(1), // Queue supports compute operations + VK_QUEUE_DMA_BIT = VK_BIT(2), // Queue supports DMA operations + VK_QUEUE_MEMMGR_BIT = VK_BIT(3), // Queue supports memory management operations + VK_QUEUE_EXTENDED_BIT = VK_BIT(30), // Extended queue +} VkQueueFlagBits; + +// Memory properties passed into vkAllocMemory(). +typedef VkFlags VkMemoryPropertyFlags; +typedef enum VkMemoryPropertyFlagBits_ +{ + VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, // If otherwise stated, then allocate memory on device + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0), // Memory should be mappable by host + VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1), // Memory should be coherent between host and device accesses + VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2), // Memory should not be cached by the host + VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3), // Memory should support host write combining + VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4), // If set, prefer host access + VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5), +} VkMemoryPropertyFlagBits; + +// Memory output flags passed to resource transition commands +typedef VkFlags VkMemoryOutputFlags; +typedef enum VkMemoryOutputFlagBits_ +{ + VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0), // Controls output coherency of CPU writes + VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1), // Controls output coherency of generic shader writes + VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2), // Controls output coherency of color attachment writes + VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3), // Controls output coherency of depth/stencil attachment writes + VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4), // Controls output coherency of transfer operations +} VkMemoryOutputFlagBits; + +// Memory input flags passed to resource transition commands +typedef VkFlags VkMemoryInputFlags; +typedef enum VkMemoryInputFlagBits_ +{ + VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0), // Controls input coherency of CPU reads + VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1), // Controls input coherency of indirect command reads + VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2), // Controls input coherency of index fetches + VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3), // Controls input coherency of vertex attribute fetches + VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4), // Controls input coherency of uniform buffer reads + VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5), // Controls input coherency of generic shader reads + VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6), // Controls input coherency of color attachment reads + VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7), // Controls input coherency of depth/stencil attachment reads + VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8), // Controls input coherency of transfer operations +} VkMemoryInputFlagBits; + +// Buffer usage flags +typedef VkFlags VkBufferUsageFlags; +typedef enum VkBufferUsageFlagBits_ +{ + VK_BUFFER_USAGE_GENERAL = 0, // No special usage + VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations + VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2), // Can be used as TBO + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3), // Can be used as IBO + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4), // Can be used as UBO + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5), // Can be used as SSBO + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6), // Can be used as source of fixed function index fetch (index buffer) + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7), // Can be used as source of fixed function vertex fetch (VBO) + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8), // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) +} VkBufferUsageFlagBits; + +// Buffer creation flags +typedef VkFlags VkBufferCreateFlags; +typedef enum VkBufferCreateFlagBits_ +{ + VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0), // Buffer should be shareable + VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1), // Buffer should support sparse backing +} VkBufferCreateFlagBits; + +// Shader stage flags +typedef VkFlags VkShaderStageFlags; +typedef enum VkShaderStageFlagBits_ +{ + VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0), + VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1), + VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2), + VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3), + VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4), + VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5), + + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, +} VkShaderStageFlagBits; + +// Image usage flags +typedef VkFlags VkImageUsageFlags; +typedef enum VkImageUsageFlagBits_ +{ + VK_IMAGE_USAGE_GENERAL = 0, // No special usage + VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations + VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations + VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2), // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3), // Can be used as storage image (STORAGE_IMAGE descriptor type) + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4), // Can be used as framebuffer color attachment + VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5), // Can be used as framebuffer depth/stencil attachment + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6), // Image data not needed outside of rendering +} VkImageUsageFlagBits; + +// Image creation flags +typedef VkFlags VkImageCreateFlags; +typedef enum VkImageCreateFlagBits_ +{ + VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0), + VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1), + VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2), // Image should be shareable + VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3), // Image should support sparse backing + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4), // Allows image views to have different format than the base image + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5), // Allows creating image views with cube type from the created image +} VkImageCreateFlagBits; // Depth-stencil view creation flags -typedef enum VkDepthStencilViewCreateFlags_ +typedef VkFlags VkDepthStencilViewCreateFlags; +typedef enum VkDepthStencilViewCreateFlagBits_ { - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, - VK_MAX_ENUM(VkDepthStencilViewCreateFlags) -} VkDepthStencilViewCreateFlags; + VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0), + VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1), +} VkDepthStencilViewCreateFlagBits; // Pipeline creation flags -typedef enum VkPipelineCreateFlags_ +typedef VkFlags VkPipelineCreateFlags; +typedef enum VkPipelineCreateFlagBits_ { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_MAX_ENUM(VkPipelineCreateFlags) -} VkPipelineCreateFlags; + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0), + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1), +} VkPipelineCreateFlagBits; + +// Channel flags +typedef VkFlags VkChannelFlags; +typedef enum VkChannelFlagBits_ +{ + VK_CHANNEL_R_BIT = VK_BIT(0), + VK_CHANNEL_G_BIT = VK_BIT(1), + VK_CHANNEL_B_BIT = VK_BIT(2), + VK_CHANNEL_A_BIT = VK_BIT(3), +} VkChannelFlagBits; // Fence creation flags -typedef enum VkFenceCreateFlags_ +typedef VkFlags VkFenceCreateFlags; +typedef enum VkFenceCreateFlagBits_ { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_MAX_ENUM(VkFenceCreateFlags) -} VkFenceCreateFlags; + VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0), +} VkFenceCreateFlagBits; // Semaphore creation flags -typedef enum VkSemaphoreCreateFlags_ +typedef VkFlags VkSemaphoreCreateFlags; +typedef enum VkSemaphoreCreateFlagBits_ { - VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, - VK_MAX_ENUM(VkSemaphoreCreateFlags) -} VkSemaphoreCreateFlags; + VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0), +} VkSemaphoreCreateFlagBits; // Format capability flags -typedef enum VkFormatFeatureFlags_ -{ - VK_FORMAT_SAMPLED_IMAGE_BIT = 0x00000001, // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_FORMAT_STORAGE_IMAGE_BIT = 0x00000002, // Format can be used for storage images (STORAGE_IMAGE descriptor type) - VK_FORMAT_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, // Format supports atomic operations in case it's used for storage images - VK_FORMAT_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, // Format can be used for uniform texel buffers (TBOs) - VK_FORMAT_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, // Format can be used for storage texel buffers (IBOs) - VK_FORMAT_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, // Format supports atomic operations in case it's used for storage texel buffers - VK_FORMAT_VERTEX_BUFFER_BIT = 0x00000040, // Format can be used for vertex buffers (VBOs) - VK_FORMAT_COLOR_ATTACHMENT_BIT = 0x00000080, // Format can be used for color attachment images - VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, // Format supports blending in case it's used for color attachment images - VK_FORMAT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, // Format can be used for depth/stencil attachment images - VK_FORMAT_CONVERSION_BIT = 0x00000400, // Format can be used as the source or destination of format converting blits - VK_MAX_ENUM(VkFormatFeatureFlags) -} VkFormatFeatureFlags; - -// Query flags -typedef enum VkQueryControlFlags_ -{ - VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001, - VK_MAX_ENUM(VkQueryControlFlags) -} VkQueryControlFlags; +typedef VkFlags VkFormatFeatureFlags; +typedef enum VkFormatFeatureFlagBits_ +{ + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0), // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1), // Format can be used for storage images (STORAGE_IMAGE descriptor type) + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2), // Format supports atomic operations in case it's used for storage images + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3), // Format can be used for uniform texel buffers (TBOs) + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4), // Format can be used for storage texel buffers (IBOs) + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5), // Format supports atomic operations in case it's used for storage texel buffers + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6), // Format can be used for vertex buffers (VBOs) + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7), // Format can be used for color attachment images + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8), // Format supports blending in case it's used for color attachment images + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9), // Format can be used for depth/stencil attachment images + VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10), // Format can be used as the source or destination of format converting blits +} VkFormatFeatureFlagBits; + +// Query control flags +typedef VkFlags VkQueryControlFlags; +typedef enum VkQueryControlFlagBits_ +{ + VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0), // Allow conservative results to be collected by the query +} VkQueryControlFlagBits; // Query result flags -typedef enum VkQueryResultFlags_ -{ - VK_QUERY_RESULT_32_BIT = 0x00000000, // Results of the queries are written to the destination buffer as 32-bit values - VK_QUERY_RESULT_64_BIT = 0x00000001, // Results of the queries are written to the destination buffer as 64-bit values - // Duplicate enum result messes with validation -// VK_QUERY_RESULT_NO_WAIT_BIT = 0x00000000, // Results of the queries aren't waited on before proceeding with the result copy - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, // Results of the queries are waited on before proceeding with the result copy - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, // Besides the results of the query, the availability of the results is also written - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008 // Copy the partial results of the query even if the final results aren't available -} VkQueryResultFlags; - -// GPU compatibility flags -typedef enum VkGpuCompatibilityFlags_ -{ - VK_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001, - VK_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002, - VK_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004, - VK_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008, - VK_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010, - VK_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020, - VK_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040, - VK_MAX_ENUM(VkGpuCompatibilityFlags) -} VkGpuCompatibilityFlags; - -// Command buffer building flags -typedef enum VkCmdBufferBuildFlags_ -{ - VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001, - VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, - VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, - VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - VK_MAX_ENUM(VkCmdBufferBuildFlags) -} VkCmdBufferBuildFlags; +typedef VkFlags VkQueryResultFlags; +typedef enum VkQueryResultFlagBits_ +{ + VK_QUERY_RESULT_32_BIT = 0, // Results of the queries are written to the destination buffer as 32-bit values + VK_QUERY_RESULT_64_BIT = VK_BIT(0), // Results of the queries are written to the destination buffer as 64-bit values + // VK_QUERY_RESULT_NO_WAIT_BIT = 0, // Results of the queries aren't waited on before proceeding with the result copy + VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1), // Results of the queries are waited on before proceeding with the result copy + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2), // Besides the results of the query, the availability of the results is also written + VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3), // Copy the partial results of the query even if the final results aren't available +} VkQueryResultFlagBits; + +// Physical device compatibility flags +typedef VkFlags VkPhysicalDeviceCompatibilityFlags; +typedef enum VkPhysicalDeviceCompatibilityFlagBits_ +{ + VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT = VK_BIT(0), + VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT = VK_BIT(1), + VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT = VK_BIT(2), + VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT = VK_BIT(3), + VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT = VK_BIT(4), + VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5), + VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6), +} VkPhysicalDeviceCompatibilityFlagBits; + +// Shader creation flags +typedef VkFlags VkShaderCreateFlags; + +// Event creation flags +typedef VkFlags VkEventCreateFlags; + +// Command buffer creation flags +typedef VkFlags VkCmdBufferCreateFlags; + +// Command buffer optimization flags +typedef VkFlags VkCmdBufferOptimizeFlags; +typedef enum VkCmdBufferOptimizeFlagBits_ +{ + VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0), + VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1), + VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2), + VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3), +} VkCmdBufferOptimizeFlagBits; + +// Memory mapping flags +typedef VkFlags VkMemoryMapFlags; // ------------------------------------------------------------------------------------------------ // Vulkan structures @@ -1295,15 +1190,15 @@ typedef struct VkChannelMapping_ VkChannelSwizzle a; } VkChannelMapping; -typedef struct VkPhysicalGpuProperties_ +typedef struct VkPhysicalDeviceProperties_ { uint32_t apiVersion; uint32_t driverVersion; uint32_t vendorId; uint32_t deviceId; - VkPhysicalGpuType gpuType; - char gpuName[VK_MAX_PHYSICAL_GPU_NAME]; - VkGpuSize maxInlineMemoryUpdateSize; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; + VkDeviceSize maxInlineMemoryUpdateSize; uint32_t maxBoundDescriptorSets; uint32_t maxThreadGroupSize; uint64_t timestampFrequency; @@ -1311,21 +1206,21 @@ typedef struct VkPhysicalGpuProperties_ uint32_t maxDescriptorSets; // at least 2? uint32_t maxViewports; // at least 16? uint32_t maxColorAttachments; // at least 8? -} VkPhysicalGpuProperties; +} VkPhysicalDeviceProperties; -typedef struct VkPhysicalGpuPerformance_ +typedef struct VkPhysicalDevicePerformance_ { - float maxGpuClock; + float maxDeviceClock; float aluPerClock; float texPerClock; float primsPerClock; float pixelsPerClock; -} VkPhysicalGpuPerformance; +} VkPhysicalDevicePerformance; -typedef struct VkGpuCompatibilityInfo_ +typedef struct VkPhysicalDeviceCompatibilityInfo_ { - VkFlags compatibilityFlags; // VkGpuCompatibilityFlags -} VkGpuCompatibilityInfo; + VkPhysicalDeviceCompatibilityFlags compatibilityFlags; +} VkPhysicalDeviceCompatibilityInfo; typedef struct VkExtensionProperties_ { @@ -1375,7 +1270,7 @@ typedef struct VkDeviceCreateInfo_ const VkDeviceQueueCreateInfo* pRequestedQueues; uint32_t extensionCount; const char*const* ppEnabledExtensionNames; - VkFlags flags; // VkDeviceCreateFlags + VkDeviceCreateFlags flags; // Device creation flags } VkDeviceCreateInfo; typedef struct VkInstanceCreateInfo_ @@ -1397,27 +1292,27 @@ typedef struct _VkLayerCreateInfo const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers()) } VkLayerCreateInfo; -typedef struct VkPhysicalGpuQueueProperties_ +typedef struct VkPhysicalDeviceQueueProperties_ { - VkFlags queueFlags; // VkQueueFlags + VkQueueFlags queueFlags; // Queue flags uint32_t queueCount; uint32_t maxAtomicCounters; bool32_t supportsTimestamps; uint32_t maxMemReferences; // Tells how many memory references can be active for the given queue -} VkPhysicalGpuQueueProperties; +} VkPhysicalDeviceQueueProperties; -typedef struct VkPhysicalGpuMemoryProperties_ +typedef struct VkPhysicalDeviceMemoryProperties_ { bool32_t supportsMigration; bool32_t supportsPinning; -} VkPhysicalGpuMemoryProperties; +} VkPhysicalDeviceMemoryProperties; typedef struct VkMemoryAllocInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO const void* pNext; // Pointer to next structure - VkGpuSize allocationSize; // Size of memory allocation - VkFlags memProps; // VkMemoryPropertyFlags + VkDeviceSize allocationSize; // Size of memory allocation + VkMemoryPropertyFlags memProps; // Memory property flags VkMemoryPriority memPriority; } VkMemoryAllocInfo; @@ -1425,29 +1320,29 @@ typedef struct VkMemoryOpenInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - VkGpuMemory sharedMem; + VkDeviceMemory sharedMem; } VkMemoryOpenInfo; typedef struct VkPeerMemoryOpenInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - VkGpuMemory originalMem; + VkDeviceMemory originalMem; } VkPeerMemoryOpenInfo; typedef struct VkMemoryRequirements_ { - VkGpuSize size; // Specified in bytes - VkGpuSize alignment; // Specified in bytes - VkGpuSize granularity; // Granularity on which vkQueueBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) + VkDeviceSize size; // Specified in bytes + VkDeviceSize alignment; // Specified in bytes + VkDeviceSize granularity; // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) VkMemoryPropertyFlags memPropsAllowed; // Allowed memory property flags VkMemoryPropertyFlags memPropsRequired; // Required memory property flags } VkMemoryRequirements; typedef struct VkFormatProperties_ { - VkFlags linearTilingFeatures; // VkFormatFeatureFlags - VkFlags optimalTilingFeatures; // VkFormatFeatureFlags + VkFormatFeatureFlags linearTilingFeatures; // Format features in case of linear tiling + VkFormatFeatureFlags optimalTilingFeatures; // Format features in case of optimal tiling } VkFormatProperties; typedef struct VkBufferViewAttachInfo_ @@ -1528,9 +1423,9 @@ typedef struct VkBufferCreateInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure. - VkGpuSize size; // Specified in bytes - VkFlags usage; // VkBufferUsageFlags - VkFlags flags; // VkBufferCreateFlags + VkDeviceSize size; // Specified in bytes + VkBufferUsageFlags usage; // Buffer usage flags + VkBufferCreateFlags flags; // Buffer creation flags } VkBufferCreateInfo; typedef struct VkBufferViewCreateInfo_ @@ -1540,8 +1435,8 @@ typedef struct VkBufferViewCreateInfo_ VkBuffer buffer; VkBufferViewType viewType; VkFormat format; // Optionally specifies format of elements - VkGpuSize offset; // Specified in bytes - VkGpuSize range; // View size specified in bytes + VkDeviceSize offset; // Specified in bytes + VkDeviceSize range; // View size specified in bytes } VkBufferViewCreateInfo; typedef struct VkImageSubresource_ @@ -1560,41 +1455,13 @@ typedef struct VkImageSubresourceRange_ uint32_t arraySize; } VkImageSubresourceRange; -typedef struct VkEventWaitInfo_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO - const void* pNext; // Pointer to next structure. - - uint32_t eventCount; // Number of events to wait on - const VkEvent* pEvents; // Array of event objects to wait on - - VkWaitEvent waitEvent; // Pipeline event where the wait should happen - - uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VkMemoryBarrier, VkBufferMemoryBarrier, or VkImageMemoryBarrier) -} VkEventWaitInfo; - -typedef struct VkPipelineBarrier_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER - const void* pNext; // Pointer to next structure. - - uint32_t eventCount; // Number of events to wait on - const VkPipeEvent* pEvents; // Array of pipeline events to wait on - - VkWaitEvent waitEvent; // Pipeline event where the wait should happen - - uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VkMemoryBarrier, VkBufferMemoryBarrier, or VkImageMemoryBarrier) -} VkPipelineBarrier; - typedef struct VkMemoryBarrier_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) - VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) + VkMemoryOutputFlags outputMask; // Outputs the barrier should sync + VkMemoryInputFlags inputMask; // Inputs the barrier should sync to } VkMemoryBarrier; typedef struct VkBufferMemoryBarrier_ @@ -1602,13 +1469,13 @@ typedef struct VkBufferMemoryBarrier_ VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) - VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) + VkMemoryOutputFlags outputMask; // Outputs the barrier should sync + VkMemoryInputFlags inputMask; // Inputs the barrier should sync to VkBuffer buffer; // Buffer to sync - VkGpuSize offset; // Offset within the buffer to sync - VkGpuSize size; // Amount of bytes to sync + VkDeviceSize offset; // Offset within the buffer to sync + VkDeviceSize size; // Amount of bytes to sync } VkBufferMemoryBarrier; typedef struct VkImageMemoryBarrier_ @@ -1616,8 +1483,8 @@ typedef struct VkImageMemoryBarrier_ VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) - VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) + VkMemoryOutputFlags outputMask; // Outputs the barrier should sync + VkMemoryInputFlags inputMask; // Inputs the barrier should sync to VkImageLayout oldLayout; // Current layout of the image VkImageLayout newLayout; // New layout to transition the image to @@ -1638,8 +1505,8 @@ typedef struct VkImageCreateInfo_ uint32_t arraySize; uint32_t samples; VkImageTiling tiling; - VkFlags usage; // VkImageUsageFlags - VkFlags flags; // VkImageCreateFlags + VkImageUsageFlags usage; // Image usage flags + VkImageCreateFlags flags; // Image creation flags } VkImageCreateInfo; typedef struct VkPeerImageOpenInfo_ @@ -1649,10 +1516,10 @@ typedef struct VkPeerImageOpenInfo_ typedef struct VkSubresourceLayout_ { - VkGpuSize offset; // Specified in bytes - VkGpuSize size; // Specified in bytes - VkGpuSize rowPitch; // Specified in bytes - VkGpuSize depthPitch; // Specified in bytes + VkDeviceSize offset; // Specified in bytes + VkDeviceSize size; // Specified in bytes + VkDeviceSize rowPitch; // Specified in bytes + VkDeviceSize depthPitch; // Specified in bytes } VkSubresourceLayout; typedef struct VkImageViewCreateInfo_ @@ -1690,7 +1557,7 @@ typedef struct VkDepthStencilViewCreateInfo_ uint32_t arraySize; VkImage msaaResolveImage; VkImageSubresourceRange msaaResolveSubResource; - VkFlags flags; // VkDepthStencilViewCreateFlags + VkDepthStencilViewCreateFlags flags; // Depth stencil attachment view flags } VkDepthStencilViewCreateInfo; typedef struct VkColorAttachmentBindInfo_ @@ -1707,9 +1574,9 @@ typedef struct VkDepthStencilBindInfo_ typedef struct VkBufferCopy_ { - VkGpuSize srcOffset; // Specified in bytes - VkGpuSize destOffset; // Specified in bytes - VkGpuSize copySize; // Specified in bytes + VkDeviceSize srcOffset; // Specified in bytes + VkDeviceSize destOffset; // Specified in bytes + VkDeviceSize copySize; // Specified in bytes } VkBufferCopy; typedef struct VkImageMemoryBindInfo_ @@ -1740,7 +1607,7 @@ typedef struct VkImageBlit_ typedef struct VkBufferImageCopy_ { - VkGpuSize bufferOffset; // Specified in bytes + VkDeviceSize bufferOffset; // Specified in bytes VkImageSubresource imageSubresource; VkOffset3D imageOffset; // Specified in pixels for both compressed and uncompressed images VkExtent3D imageExtent; // Specified in pixels for both compressed and uncompressed images @@ -1761,23 +1628,23 @@ typedef struct VkShaderCreateInfo_ const void* pNext; // Pointer to next structure size_t codeSize; // Specified in bytes const void* pCode; - VkFlags flags; // Reserved + VkShaderCreateFlags flags; // Reserved } VkShaderCreateInfo; typedef struct VkDescriptorSetLayoutBinding_ { - VkDescriptorType descriptorType; - uint32_t count; - VkFlags stageFlags; // VkShaderStageFlags - const VkSampler* pImmutableSamplers; + VkDescriptorType descriptorType; // Type of the descriptors in this binding + uint32_t count; // Number of descriptors in this binding + VkShaderStageFlags stageFlags; // Shader stages this binding is visible to + const VkSampler* pImmutableSamplers; // Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements) } VkDescriptorSetLayoutBinding; typedef struct VkDescriptorSetLayoutCreateInfo_ { - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO - const void* pNext; // Pointer to next structure - uint32_t count; // Number of bindings in the descriptor set layout - const VkDescriptorSetLayoutBinding* pBinding; // Array of descriptor set layout bindings + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO + const void* pNext; // Pointer to next structure + uint32_t count; // Number of bindings in the descriptor set layout + const VkDescriptorSetLayoutBinding* pBinding; // Array of descriptor set layout bindings } VkDescriptorSetLayoutCreateInfo; typedef struct VkDescriptorTypeCount_ @@ -1816,7 +1683,7 @@ typedef struct VkSpecializationInfo_ typedef struct VkPipelineShader_ { - VkPipelineShaderStage stage; + VkShaderStage stage; VkShader shader; uint32_t linkConstBufferCount; const VkLinkConstBuffer* pLinkConstBufferInfo; @@ -1825,10 +1692,10 @@ typedef struct VkPipelineShader_ typedef struct VkComputePipelineCreateInfo_ { - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext; // Pointer to next structure + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO + const void* pNext; // Pointer to next structure VkPipelineShader cs; - VkFlags flags; // VkPipelineCreateFlags + VkPipelineCreateFlags flags; // Pipeline creation flags VkDescriptorSetLayoutChain setLayoutChain; uint32_t localSizeX; uint32_t localSizeY; @@ -1887,7 +1754,7 @@ typedef struct VkPipelineVpStateCreateInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO const void* pNext; // Pointer to next structure - uint32_t numViewports; + uint32_t viewportCount; VkCoordinateOrigin clipOrigin; // optional (GL45) VkDepthMode depthMode; // optional (GL45) } VkPipelineVpStateCreateInfo; @@ -1900,10 +1767,10 @@ typedef struct VkPipelineRsStateCreateInfo_ bool32_t rasterizerDiscardEnable; bool32_t programPointSize; // optional (GL45) VkCoordinateOrigin pointOrigin; // optional (GL45) - VkProvokingVertexConvention provokingVertex; // optional (GL45) + VkProvokingVertex provokingVertex; // optional (GL45) VkFillMode fillMode; // optional (GL45) VkCullMode cullMode; - VkFaceOrientation frontFace; + VkFrontFace frontFace; } VkPipelineRsStateCreateInfo; typedef struct VkPipelineMsStateCreateInfo_ @@ -1923,11 +1790,11 @@ typedef struct VkPipelineCbAttachmentState_ VkFormat format; VkBlend srcBlendColor; VkBlend destBlendColor; - VkBlendFunc blendFuncColor; + VkBlendOp blendOpColor; VkBlend srcBlendAlpha; VkBlend destBlendAlpha; - VkBlendFunc blendFuncAlpha; - uint8_t channelWriteMask; + VkBlendOp blendOpAlpha; + VkChannelFlags channelWriteMask; } VkPipelineCbAttachmentState; typedef struct VkPipelineCbStateCreateInfo_ @@ -1946,7 +1813,7 @@ typedef struct VkStencilOpState_ VkStencilOp stencilFailOp; VkStencilOp stencilPassOp; VkStencilOp stencilDepthFailOp; - VkCompareFunc stencilFunc; + VkCompareOp stencilCompareOp; } VkStencilOpState; typedef struct VkPipelineDsStateCreateInfo_ @@ -1956,7 +1823,7 @@ typedef struct VkPipelineDsStateCreateInfo_ VkFormat format; bool32_t depthTestEnable; bool32_t depthWriteEnable; - VkCompareFunc depthFunc; + VkCompareOp depthCompareOp; bool32_t depthBoundsEnable; // optional (depth_bounds_test) bool32_t stencilTestEnable; VkStencilOpState front; @@ -1974,7 +1841,7 @@ typedef struct VkGraphicsPipelineCreateInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure - VkFlags flags; // VkPipelineCreateFlags + VkPipelineCreateFlags flags; // Pipeline creation flags VkDescriptorSetLayoutChain pSetLayoutChain; } VkGraphicsPipelineCreateInfo; @@ -1990,10 +1857,10 @@ typedef struct VkSamplerCreateInfo_ VkTexAddress addressW; float mipLodBias; uint32_t maxAnisotropy; - VkCompareFunc compareFunc; + VkCompareOp compareOp; float minLod; float maxLod; - VkBorderColorType borderColorType; + VkBorderColor borderColor; } VkSamplerCreateInfo; typedef struct VkDynamicVpStateCreateInfo_ @@ -2041,7 +1908,7 @@ typedef struct VkCmdBufferCreateInfo_ VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t queueNodeIndex; - VkFlags flags; + VkCmdBufferCreateFlags flags; // Command buffer creation flags } VkCmdBufferCreateInfo; typedef struct VkCmdBufferBeginInfo_ @@ -2049,7 +1916,7 @@ typedef struct VkCmdBufferBeginInfo_ VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO const void* pNext; // Pointer to next structure - VkFlags flags; // VkCmdBufferBuildFlags + VkCmdBufferOptimizeFlags flags; // Command buffer optimization flags } VkCmdBufferBeginInfo; typedef struct VkRenderPassBegin_ @@ -2108,14 +1975,14 @@ typedef struct VkEventCreateInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO const void* pNext; // Pointer to next structure - VkFlags flags; // Reserved + VkEventCreateFlags flags; // Event creation flags } VkEventCreateInfo; typedef struct VkFenceCreateInfo_ { VkStructureType sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO const void* pNext; // Pointer to next structure - VkFenceCreateFlags flags; // VkFenceCreateFlags + VkFenceCreateFlags flags; // Fence creation flags } VkFenceCreateInfo; typedef struct VkSemaphoreCreateInfo_ @@ -2123,7 +1990,7 @@ typedef struct VkSemaphoreCreateInfo_ VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t initialCount; - VkFlags flags; // VkSemaphoreCreateFlags + VkSemaphoreCreateFlags flags; // Semaphore creation flags } VkSemaphoreCreateInfo; typedef struct VkSemaphoreOpenInfo_ @@ -2199,36 +2066,37 @@ typedef struct VkDispatchIndirectCmd_ // API functions typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); -typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalGpu* pPhysicalDevices); -typedef VkResult (VKAPI *PFN_vkGetGpuInfo)(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData); -typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalGpu gpu, const char * pName); -typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); +typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData); +typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalDevice physicalDevice, const char * pName); +typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalGpu gpu, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalDevice gpu, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkGetExtensionSupport)(VkPhysicalDevice physicalDevice, const char* pExtName); +typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue); typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); -typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkGpuMemory* pMems); -typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t count, const VkGpuMemory* pMems); +typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems); +typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems); typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkGpuMemory mem); -typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkGpuMemory mem, VkMemoryPriority priority); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkGpuMemory mem, VkFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkGpuMemory mem); -typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem); -typedef VkResult (VKAPI *PFN_vkGetMultiGpuCompatibility)(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo); -typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); +typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkDeviceMemory mem, VkMemoryPriority priority); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDeviceMemory mem, VkFlags flags, void** ppData); +typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem); +typedef VkResult (VKAPI *PFN_vkGetMultiDeviceCompatibility)(VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo); +typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkOpenSharedSemaphore)(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem); -typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); +typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkObject object); typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset,VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset); -typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkGpuMemory mem, VkGpuSize memOffset); +typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset); +typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset,VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset); typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences); typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkFence fence); @@ -2241,7 +2109,7 @@ typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkEvent event); typedef VkResult (VKAPI *PFN_vkSetEvent)(VkEvent event); typedef VkResult (VKAPI *PFN_vkResetEvent)(VkEvent event); typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); typedef VkResult (VKAPI *PFN_vkGetFormatInfo)(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData); typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); @@ -2266,7 +2134,7 @@ typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescript typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); typedef void (VKAPI *PFN_vkClearDescriptorSets)(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** pUpdateArray); +typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray); typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState); typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState); typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState); @@ -2278,37 +2146,37 @@ typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer); typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); typedef void (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state); typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData); -typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType); -typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkGpuSize* pOffsets); +typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset); +typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions); 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_vkCmdCloneImageData)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout); -typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data); +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_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); typedef void (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); -typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo); -typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier); -typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags); +typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset); -typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize destStride, VkFlags flags); +typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); +typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkFlags flags); typedef void (VKAPI *PFN_vkCmdInitAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdLoadAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset); -typedef void (VKAPI *PFN_vkCmdSaveAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset); +typedef void (VKAPI *PFN_vkCmdLoadAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset); +typedef void (VKAPI *PFN_vkCmdSaveAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin); @@ -2316,7 +2184,7 @@ typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer, VkRender #ifdef VK_PROTOTYPES -// GPU initialization +// Device initialization VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, @@ -2328,22 +2196,22 @@ VkResult VKAPI vkDestroyInstance( VkResult VKAPI vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, - VkPhysicalGpu* pPhysicalDevices); + VkPhysicalDevice* pPhysicalDevices); -VkResult VKAPI vkGetGpuInfo( - VkPhysicalGpu gpu, - VkPhysicalGpuInfoType infoType, +VkResult VKAPI vkGetPhysicalDeviceInfo( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData); void * VKAPI vkGetProcAddr( - VkPhysicalGpu gpu, + VkPhysicalDevice physicalDevice, const char* pName); // Device functions VkResult VKAPI vkCreateDevice( - VkPhysicalGpu gpu, + VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); @@ -2358,7 +2226,7 @@ VkResult VKAPI vkGetGlobalExtensionInfo( void* pData); VkResult VKAPI vkGetPhysicalDeviceExtensionInfo( - VkPhysicalGpu gpu, + VkPhysicalDevice gpu, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, @@ -2367,7 +2235,7 @@ VkResult VKAPI vkGetPhysicalDeviceExtensionInfo( // Layer discovery functions VkResult VKAPI vkEnumerateLayers( - VkPhysicalGpu gpu, + VkPhysicalDevice physicalDevice, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, @@ -2391,12 +2259,12 @@ VkResult VKAPI vkQueueSubmit( VkResult VKAPI vkQueueAddMemReferences( VkQueue queue, uint32_t count, - const VkGpuMemory* pMems); + const VkDeviceMemory* pMems); VkResult VKAPI vkQueueRemoveMemReferences( VkQueue queue, uint32_t count, - const VkGpuMemory* pMems); + const VkDeviceMemory* pMems); VkResult VKAPI vkQueueWaitIdle( VkQueue queue); @@ -2409,40 +2277,40 @@ VkResult VKAPI vkDeviceWaitIdle( VkResult VKAPI vkAllocMemory( VkDevice device, const VkMemoryAllocInfo* pAllocInfo, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); VkResult VKAPI vkFreeMemory( - VkGpuMemory mem); + VkDeviceMemory mem); VkResult VKAPI vkSetMemoryPriority( - VkGpuMemory mem, + VkDeviceMemory mem, VkMemoryPriority priority); VkResult VKAPI vkMapMemory( - VkGpuMemory mem, - VkFlags flags, // Reserved + VkDeviceMemory mem, + VkMemoryMapFlags flags, void** ppData); VkResult VKAPI vkUnmapMemory( - VkGpuMemory mem); + VkDeviceMemory mem); VkResult VKAPI vkPinSystemMemory( VkDevice device, const void* pSysMem, size_t memSize, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); // Multi-device functions -VkResult VKAPI vkGetMultiGpuCompatibility( - VkPhysicalGpu gpu0, - VkPhysicalGpu gpu1, - VkGpuCompatibilityInfo* pInfo); +VkResult VKAPI vkGetMultiDeviceCompatibility( + VkPhysicalDevice physicalDevice0, + VkPhysicalDevice physicalDevice1, + VkPhysicalDeviceCompatibilityInfo* pInfo); VkResult VKAPI vkOpenSharedMemory( VkDevice device, const VkMemoryOpenInfo* pOpenInfo, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); VkResult VKAPI vkOpenSharedSemaphore( VkDevice device, @@ -2452,13 +2320,13 @@ VkResult VKAPI vkOpenSharedSemaphore( VkResult VKAPI vkOpenPeerMemory( VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); VkResult VKAPI vkOpenPeerImage( VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, - VkGpuMemory* pMem); + VkDeviceMemory* pMem); // Generic API object functions @@ -2477,25 +2345,25 @@ VkResult VKAPI vkQueueBindObjectMemory( VkQueue queue, VkObject object, uint32_t allocationIdx, - VkGpuMemory mem, - VkGpuSize memOffset); + VkDeviceMemory mem, + VkDeviceSize memOffset); VkResult VKAPI vkQueueBindObjectMemoryRange( VkQueue queue, VkObject object, uint32_t allocationIdx, - VkGpuSize rangeOffset, - VkGpuSize rangeSize, - VkGpuMemory mem, - VkGpuSize memOffset); + VkDeviceSize rangeOffset, + VkDeviceSize rangeSize, + VkDeviceMemory mem, + VkDeviceSize memOffset); VkResult VKAPI vkQueueBindImageMemoryRange( VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, - VkGpuMemory mem, - VkGpuSize memOffset); + VkDeviceMemory mem, + VkDeviceSize memOffset); // Fence functions @@ -2562,7 +2430,8 @@ VkResult VKAPI vkGetQueryPoolResults( uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, - void* pData); + void* pData, + VkQueryResultFlags flags); // Format capabilities @@ -2715,7 +2584,7 @@ void VKAPI vkClearDescriptorSets( void VKAPI vkUpdateDescriptors( VkDescriptorSet descriptorSet, uint32_t updateCount, - const void** pUpdateArray); + const void** ppUpdateArray); // State object functions @@ -2775,12 +2644,12 @@ void VKAPI vkCmdBindDescriptorSets( uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, - const uint32_t* pUserData); + const uint32_t * pUserData); void VKAPI vkCmdBindIndexBuffer( VkCmdBuffer cmdBuffer, VkBuffer buffer, - VkGpuSize offset, + VkDeviceSize offset, VkIndexType indexType); void VKAPI vkCmdBindVertexBuffers( @@ -2788,7 +2657,7 @@ void VKAPI vkCmdBindVertexBuffers( uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, - const VkGpuSize* pOffsets); + const VkDeviceSize* pOffsets); void VKAPI vkCmdDraw( VkCmdBuffer cmdBuffer, @@ -2808,14 +2677,14 @@ void VKAPI vkCmdDrawIndexed( void VKAPI vkCmdDrawIndirect( VkCmdBuffer cmdBuffer, VkBuffer buffer, - VkGpuSize offset, + VkDeviceSize offset, uint32_t count, uint32_t stride); void VKAPI vkCmdDrawIndexedIndirect( VkCmdBuffer cmdBuffer, VkBuffer buffer, - VkGpuSize offset, + VkDeviceSize offset, uint32_t count, uint32_t stride); @@ -2828,7 +2697,7 @@ void VKAPI vkCmdDispatch( void VKAPI vkCmdDispatchIndirect( VkCmdBuffer cmdBuffer, VkBuffer buffer, - VkGpuSize offset); + VkDeviceSize offset); void VKAPI vkCmdCopyBuffer( VkCmdBuffer cmdBuffer, @@ -2881,15 +2750,15 @@ void VKAPI vkCmdCloneImageData( void VKAPI vkCmdUpdateBuffer( VkCmdBuffer cmdBuffer, VkBuffer destBuffer, - VkGpuSize destOffset, - VkGpuSize dataSize, + VkDeviceSize destOffset, + VkDeviceSize dataSize, const uint32_t* pData); void VKAPI vkCmdFillBuffer( VkCmdBuffer cmdBuffer, VkBuffer destBuffer, - VkGpuSize destOffset, - VkGpuSize fillSize, + VkDeviceSize destOffset, + VkDeviceSize fillSize, uint32_t data); void VKAPI vkCmdClearColorImage( @@ -2930,17 +2799,25 @@ void VKAPI vkCmdResetEvent( void VKAPI vkCmdWaitEvents( VkCmdBuffer cmdBuffer, - const VkEventWaitInfo* pWaitInfo); + VkWaitEvent waitEvent, + uint32_t eventCount, + const VkEvent* pEvents, + uint32_t memBarrierCount, + const void** ppMemBarriers); void VKAPI vkCmdPipelineBarrier( VkCmdBuffer cmdBuffer, - const VkPipelineBarrier* pBarrier); + VkWaitEvent waitEvent, + uint32_t pipeEventCount, + const VkPipeEvent* pPipeEvents, + uint32_t memBarrierCount, + const void** ppMemBarriers); void VKAPI vkCmdBeginQuery( VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, - VkFlags flags); + VkQueryControlFlags flags); void VKAPI vkCmdEndQuery( VkCmdBuffer cmdBuffer, @@ -2957,7 +2834,7 @@ void VKAPI vkCmdWriteTimestamp( VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, - VkGpuSize destOffset); + VkDeviceSize destOffset); void VKAPI vkCmdCopyQueryPoolResults( VkCmdBuffer cmdBuffer, @@ -2965,8 +2842,8 @@ void VKAPI vkCmdCopyQueryPoolResults( uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, - VkGpuSize destOffset, - VkGpuSize destStride, + VkDeviceSize destOffset, + VkDeviceSize destStride, VkFlags flags); // VkQueryResultFlags void VKAPI vkCmdInitAtomicCounters( @@ -2982,7 +2859,7 @@ void VKAPI vkCmdLoadAtomicCounters( uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, - VkGpuSize srcOffset); + VkDeviceSize srcOffset); void VKAPI vkCmdSaveAtomicCounters( VkCmdBuffer cmdBuffer, @@ -2990,7 +2867,7 @@ void VKAPI vkCmdSaveAtomicCounters( uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, - VkGpuSize destOffset); + VkDeviceSize destOffset); VkResult VKAPI vkCreateFramebuffer( VkDevice device, |