** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+** Generated on date 20150624
+*/
+
+#define VK_VERSION_1_0 1
#include "vk_platform.h"
#define VK_MAKE_VERSION(major, minor, patch) \
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 131, 0)
#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
#define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
#define VK_MAX_PHYSICAL_DEVICE_NAME 256
#define VK_UUID_LENGTH 16
#define VK_MAX_EXTENSION_NAME 256
+#define VK_MAX_DESCRIPTION 256
#define VK_MAX_MEMORY_TYPES 32
#define VK_MAX_MEMORY_HEAPS 16
#define VK_LOD_CLAMP_NONE MAX_FLOAT
#define VK_LAST_MIP_LEVEL UINT32_MAX
#define VK_LAST_ARRAY_SLICE UINT32_MAX
#define VK_WHOLE_SIZE UINT64_MAX
+#define VK_ATTACHMENT_UNUSED UINT32_MAX
#define VK_TRUE 1
#define VK_FALSE 0
#define VK_NULL_HANDLE 0
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkAttachmentView, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShaderModule, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineCache, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicViewportState, VkDynamicStateObject)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRasterState, VkDynamicStateObject)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicColorBlendState, VkDynamicStateObject)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDepthStencilState, VkDynamicStateObject)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
-// This macro defines INT_MAX in enumerations to force compilers to use 32 bits
-// 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.
-// 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))
typedef enum {
VK_SUCCESS = 0,
VK_TIMEOUT = 3,
VK_EVENT_SET = 4,
VK_EVENT_RESET = 5,
+ VK_INCOMPLETE = 6,
VK_ERROR_UNKNOWN = -1,
VK_ERROR_UNAVAILABLE = -2,
VK_ERROR_INITIALIZATION_FAILED = -3,
VK_ERROR_BUILDING_COMMAND_BUFFER = -30,
VK_ERROR_MEMORY_NOT_BOUND = -31,
VK_ERROR_INCOMPATIBLE_QUEUE = -32,
- VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_QUEUE,
- VK_RESULT_END_RANGE = VK_EVENT_RESET,
- VK_RESULT_NUM = (VK_EVENT_RESET - VK_ERROR_INCOMPATIBLE_QUEUE + 1),
+ VK_ERROR_INVALID_LAYER = -33,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+ VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1),
VK_RESULT_MAX_ENUM = 0x7FFFFFFF
} VkResult;
VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
- 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_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_STATE_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_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 52,
-
- VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, PIPELINE_LAYOUT_CREATE_INFO)
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3,
+ VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4,
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5,
+ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6,
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 12,
+ VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 13,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17,
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20,
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 23,
+ VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 27,
+ VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 28,
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29,
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34,
+ VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 35,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44,
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+ VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkStructureType;
typedef enum {
VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
} VkFormat;
+typedef enum {
+ VK_IMAGE_TYPE_1D = 0,
+ VK_IMAGE_TYPE_2D = 1,
+ VK_IMAGE_TYPE_3D = 2,
+ VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
+ VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
+ VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
+ VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkImageType;
+
+typedef enum {
+ VK_IMAGE_TILING_LINEAR = 0,
+ VK_IMAGE_TILING_OPTIMAL = 1,
+ VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR,
+ VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1),
+ VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+} VkImageTiling;
+
typedef enum {
VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
VK_OBJECT_TYPE_BUFFER_VIEW = 7,
VK_OBJECT_TYPE_IMAGE = 8,
VK_OBJECT_TYPE_IMAGE_VIEW = 9,
- VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10,
- VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11,
+ VK_OBJECT_TYPE_ATTACHMENT_VIEW = 10,
+ VK_OBJECT_TYPE_SHADER_MODULE = 11,
VK_OBJECT_TYPE_SHADER = 12,
VK_OBJECT_TYPE_PIPELINE = 13,
VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14,
VK_OBJECT_TYPE_QUERY_POOL = 26,
VK_OBJECT_TYPE_FRAMEBUFFER = 27,
VK_OBJECT_TYPE_RENDER_PASS = 28,
-
- // Valid ranges for core Vulkan:
+ VK_OBJECT_TYPE_PIPELINE_CACHE = 29,
VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
- VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_RENDER_PASS,
- VK_NUM_OBJECT_TYPE = (VK_OBJECT_TYPE_END_RANGE - VK_OBJECT_TYPE_BEGIN_RANGE + 1),
+ VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_PIPELINE_CACHE,
+ VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_PIPELINE_CACHE - VK_OBJECT_TYPE_INSTANCE + 1),
VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkObjectType;
VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkBufferViewType;
-typedef enum {
- VK_IMAGE_TYPE_1D = 0,
- VK_IMAGE_TYPE_2D = 1,
- VK_IMAGE_TYPE_3D = 2,
- VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
- VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
- VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
- VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkImageType;
-
-typedef enum {
- VK_IMAGE_TILING_LINEAR = 0,
- VK_IMAGE_TILING_OPTIMAL = 1,
- VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR,
- VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL,
- VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1),
- VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
-} VkImageTiling;
-
typedef enum {
VK_IMAGE_VIEW_TYPE_1D = 0,
VK_IMAGE_VIEW_TYPE_2D = 1,
} VkTexAddress;
typedef enum {
- VK_BORDER_COLOR_OPAQUE_WHITE = 0,
- VK_BORDER_COLOR_TRANSPARENT_BLACK = 1,
- VK_BORDER_COLOR_OPAQUE_BLACK = 2,
- VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_OPAQUE_WHITE,
- VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_OPAQUE_BLACK,
- VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_OPAQUE_BLACK - VK_BORDER_COLOR_OPAQUE_WHITE + 1),
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
+ VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
+ VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
+ VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
+ VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
+ VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
+ VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+ VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
+ VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
} VkBorderColor;
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
+ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
- VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
- VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
+ VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+ VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorType;
VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorPoolUsage;
-typedef enum {
- VK_DESCRIPTOR_UPDATE_MODE_COPY = 0,
- VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 1,
-
- VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE, COPY, FASTEST)
-} VkDescriptorUpdateMode;
-
typedef enum {
VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
typedef enum {
VK_ATTACHMENT_STORE_OP_STORE = 0,
- VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 1,
- VK_ATTACHMENT_STORE_OP_DONT_CARE = 2,
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
} VkPipelineBindPoint;
typedef enum {
- VK_STATE_BIND_POINT_VIEWPORT = 0,
- VK_STATE_BIND_POINT_RASTER = 1,
- VK_STATE_BIND_POINT_COLOR_BLEND = 2,
- VK_STATE_BIND_POINT_DEPTH_STENCIL = 3,
- VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_POINT_VIEWPORT,
- VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_POINT_DEPTH_STENCIL,
- VK_STATE_BIND_POINT_NUM = (VK_STATE_BIND_POINT_DEPTH_STENCIL - VK_STATE_BIND_POINT_VIEWPORT + 1),
- VK_STATE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
-} VkStateBindPoint;
+ VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
+ VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
+ VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY,
+ VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY,
+ VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1),
+ VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} VkCmdBufferLevel;
typedef enum {
VK_INDEX_TYPE_UINT16 = 0,
VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkIndexType;
-typedef enum {
- VK_PIPE_EVENT_TOP_OF_PIPE = 0,
- VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 1,
- VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 2,
- VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 3,
- VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 4,
- VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 5,
- VK_PIPE_EVENT_TRANSFER_COMPLETE = 6,
- VK_PIPE_EVENT_COMMANDS_COMPLETE = 7,
- VK_PIPE_EVENT_CPU_SIGNAL = 8,
- VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE,
- VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_CPU_SIGNAL,
- VK_PIPE_EVENT_NUM = (VK_PIPE_EVENT_CPU_SIGNAL - VK_PIPE_EVENT_TOP_OF_PIPE + 1),
- VK_PIPE_EVENT_MAX_ENUM = 0x7FFFFFFF
-} VkPipeEvent;
-
-typedef enum {
- VK_WAIT_EVENT_TOP_OF_PIPE = 1,
- VK_WAIT_EVENT_BEFORE_RASTERIZATION = 2,
- VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE,
- VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION,
- VK_WAIT_EVENT_NUM = (VK_WAIT_EVENT_BEFORE_RASTERIZATION - VK_WAIT_EVENT_TOP_OF_PIPE + 1),
- VK_WAIT_EVENT_MAX_ENUM = 0x7FFFFFFF
-} VkWaitEvent;
-
typedef enum {
VK_TIMESTAMP_TYPE_TOP = 0,
VK_TIMESTAMP_TYPE_BOTTOM = 1,
VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkTimestampType;
+typedef enum {
+ VK_RENDER_PASS_CONTENTS_INLINE = 0,
+ VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
+ VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
+ VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS,
+ VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
+ VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+} VkRenderPassContents;
+
+
typedef enum {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
} VkFormatFeatureFlagBits;
typedef VkFlags VkFormatFeatureFlags;
+typedef enum {
+ VK_IMAGE_USAGE_GENERAL = 0,
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
+ VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+ VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
+ VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020,
+ VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
+} VkImageUsageFlagBits;
+typedef VkFlags VkImageUsageFlags;
+
typedef enum {
VK_QUEUE_GRAPHICS_BIT = 0x00000001,
VK_QUEUE_COMPUTE_BIT = 0x00000002,
} VkMemoryPropertyFlagBits;
typedef VkFlags VkMemoryPropertyFlags;
+typedef enum {
+ VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001,
+} VkMemoryHeapFlagBits;
+typedef VkFlags VkMemoryHeapFlags;
+
typedef enum {
VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
- VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = 0x00000002,
} VkDeviceCreateFlagBits;
typedef VkFlags VkDeviceCreateFlags;
typedef VkFlags VkMemoryMapFlags;
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
-typedef enum {
- VK_IMAGE_USAGE_GENERAL = 0,
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
- VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
- VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
- VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
- VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020,
- VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
-} VkImageUsageFlagBits;
-typedef VkFlags VkImageUsageFlags;
-
typedef enum {
VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
VK_IMAGE_CREATE_SPARSE_BIT = 0x00000002,
typedef VkFlags VkImageCreateFlags;
typedef enum {
- VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
- VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
-} VkDepthStencilViewCreateFlagBits;
-typedef VkFlags VkDepthStencilViewCreateFlags;
+ VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+ VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+} VkAttachmentViewCreateFlagBits;
+typedef VkFlags VkAttachmentViewCreateFlags;
+typedef VkFlags VkShaderModuleCreateFlags;
typedef VkFlags VkShaderCreateFlags;
typedef enum {
typedef enum {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
} VkPipelineCreateFlagBits;
typedef VkFlags VkPipelineCreateFlags;
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
} VkShaderStageFlagBits;
typedef VkFlags VkShaderStageFlags;
-typedef VkFlags VkCmdBufferCreateFlags;
-
-typedef enum {
- VK_CMD_BUFFER_OPTIMIZE_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,
-} VkCmdBufferOptimizeFlagBits;
-typedef VkFlags VkCmdBufferOptimizeFlags;
-
-typedef enum {
- VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
- VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
- VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
-} VkImageAspectFlagBits;
-typedef VkFlags VkImageAspectFlags;
-
-typedef enum {
- VK_PIPE_EVENT_TOP_OF_PIPE_BIT = 0x00000001,
- VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE_BIT = 0x00000002,
- VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE_BIT = 0x00000004,
- VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE_BIT = 0x00000008,
- VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE_BIT = 0x00000010,
- VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE_BIT = 0x00000020,
- VK_PIPE_EVENT_TRANSFER_COMPLETE_BIT = 0x00000040,
- VK_PIPE_EVENT_COMMANDS_COMPLETE_BIT = 0x00000080,
- VK_PIPE_EVENT_CPU_SIGNAL_BIT = 0x00000100,
-} VkPipeEventFlagBits;
-typedef VkFlags VkPipeEventFlags;
typedef enum {
- VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
-} VkQueryControlFlagBits;
-typedef VkFlags VkQueryControlFlags;
+ VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
+} VkSubpassDescriptionFlagBits;
+typedef VkFlags VkSubpassDescriptionFlags;
+
+typedef enum {
+ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+ VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010,
+ VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020,
+ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
+ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
+ VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
+ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+ VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+ VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000,
+ VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+ VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF,
+ VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF,
+} VkPipelineStageFlagBits;
+typedef VkFlags VkPipelineStageFlags;
typedef enum {
VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001,
VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020,
VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040,
VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080,
- VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000100,
+ VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100,
+ VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200,
} VkMemoryInputFlagBits;
typedef VkFlags VkMemoryInputFlags;
+typedef VkFlags VkCmdBufferCreateFlags;
typedef enum {
- // 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_CMD_BUFFER_OPTIMIZE_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_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010,
+} VkCmdBufferOptimizeFlagBits;
+typedef VkFlags VkCmdBufferOptimizeFlags;
- VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE, PROPERTIES, MEMORY_PROPERTIES)
-} VkPhysicalDeviceInfoType;
+typedef enum {
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+} VkImageAspectFlagBits;
+typedef VkFlags VkImageAspectFlags;
-// Physical device compatibility flags
-typedef VkFlags VkPhysicalDeviceCompatibilityFlags;
typedef enum {
- 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;
+ VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
+} VkQueryControlFlagBits;
+typedef VkFlags VkQueryControlFlags;
typedef struct {
VkStructureType sType;
const void* pNext;
const VkApplicationInfo* pAppInfo;
const VkAllocCallbacks* pAllocCb;
+ uint32_t layerCount;
+ const char*const* ppEnabledLayerNames;
uint32_t extensionCount;
const char*const* ppEnabledExtensionNames;
} VkInstanceCreateInfo;
+typedef struct {
+ VkBool32 robustBufferAccess;
+ VkBool32 fullDrawIndexUint32;
+ VkBool32 imageCubeArray;
+ VkBool32 independentBlend;
+ VkBool32 geometryShader;
+ VkBool32 tessellationShader;
+ VkBool32 sampleRateShading;
+ VkBool32 dualSourceBlend;
+ VkBool32 logicOp;
+ VkBool32 instancedDrawIndirect;
+ VkBool32 depthClip;
+ VkBool32 depthBiasClamp;
+ VkBool32 fillModeNonSolid;
+ VkBool32 depthBounds;
+ VkBool32 wideLines;
+ VkBool32 largePoints;
+ VkBool32 textureCompressionETC2;
+ VkBool32 textureCompressionASTC_LDR;
+ VkBool32 textureCompressionBC;
+ VkBool32 pipelineStatisticsQuery;
+ VkBool32 vertexSideEffects;
+ VkBool32 tessellationSideEffects;
+ VkBool32 geometrySideEffects;
+ VkBool32 fragmentSideEffects;
+ VkBool32 shaderTessellationPointSize;
+ VkBool32 shaderGeometryPointSize;
+ VkBool32 shaderTextureGatherExtended;
+ VkBool32 shaderStorageImageExtendedFormats;
+ VkBool32 shaderStorageImageMultisample;
+ VkBool32 shaderStorageBufferArrayConstantIndexing;
+ VkBool32 shaderStorageImageArrayConstantIndexing;
+ VkBool32 shaderUniformBufferArrayDynamicIndexing;
+ VkBool32 shaderSampledImageArrayDynamicIndexing;
+ VkBool32 shaderStorageBufferArrayDynamicIndexing;
+ VkBool32 shaderStorageImageArrayDynamicIndexing;
+ VkBool32 shaderClipDistance;
+ VkBool32 shaderCullDistance;
+ VkBool32 shaderFloat64;
+ VkBool32 shaderInt64;
+ VkBool32 shaderFloat16;
+ VkBool32 shaderInt16;
+} VkPhysicalDeviceFeatures;
+
+typedef struct {
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
+} VkFormatProperties;
+
+typedef struct {
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ uint32_t maxTexelBufferSize;
+ uint32_t maxUniformBufferSize;
+ uint32_t maxStorageBufferSize;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ uint32_t maxBoundDescriptorSets;
+ uint32_t maxDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetStorageBuffers;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+ uint32_t maxTessGenLevel;
+ uint32_t maxTessPatchSize;
+ uint32_t maxTessControlPerVertexInputComponents;
+ uint32_t maxTessControlPerVertexOutputComponents;
+ uint32_t maxTessControlPerPatchOutputComponents;
+ uint32_t maxTessControlTotalOutputComponents;
+ uint32_t maxTessEvaluationInputComponents;
+ uint32_t maxTessEvaluationOutputComponents;
+ uint32_t maxGeometryShaderInvocations;
+ uint32_t maxGeometryInputComponents;
+ uint32_t maxGeometryOutputComponents;
+ uint32_t maxGeometryOutputVertices;
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+ uint32_t maxFragmentOutputBuffers;
+ uint32_t maxFragmentDualSourceBuffers;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+ uint32_t maxComputeWorkGroupInvocations;
+ uint32_t maxComputeWorkGroupSize[3];
+ uint32_t subPixelPrecisionBits;
+ uint32_t subTexelPrecisionBits;
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+ uint32_t maxDrawIndirectInstanceCount;
+ VkBool32 primitiveRestartForPatches;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+ uint32_t maxDynamicViewportStates;
+ uint32_t maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ uint32_t viewportSubPixelBits;
+ uint32_t minMemoryMapAlignment;
+ uint32_t minTexelBufferOffsetAlignment;
+ uint32_t minUniformBufferOffsetAlignment;
+ uint32_t minStorageBufferOffsetAlignment;
+ uint32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+ uint32_t minTexelGatherOffset;
+ uint32_t maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ uint32_t subPixelInterpolationOffsetBits;
+ uint32_t maxFramebufferWidth;
+ uint32_t maxFramebufferHeight;
+ uint32_t maxFramebufferLayers;
+ uint32_t maxFramebufferColorSamples;
+ uint32_t maxFramebufferDepthSamples;
+ uint32_t maxFramebufferStencilSamples;
+ uint32_t maxColorAttachments;
+ uint32_t maxSampledImageColorSamples;
+ uint32_t maxSampledImageDepthSamples;
+ uint32_t maxSampledImageIntegerSamples;
+ uint32_t maxStorageImageSamples;
+ uint32_t maxSampleMaskWords;
+ uint64_t timestampFrequency;
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+} VkPhysicalDeviceLimits;
+
typedef struct {
uint32_t apiVersion;
uint32_t driverVersion;
uint32_t deviceId;
VkPhysicalDeviceType deviceType;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
- VkDeviceSize maxInlineMemoryUpdateSize;
- uint32_t maxBoundDescriptorSets;
- uint32_t maxThreadGroupSize;
- uint64_t timestampFrequency;
- bool32_t multiColorAttachmentClears;
- uint32_t maxDescriptorSets;
- uint32_t maxViewports;
- uint32_t maxColorAttachments;
+ uint8_t pipelineCacheUUID[VK_UUID_LENGTH];
} VkPhysicalDeviceProperties;
typedef struct {
- float maxDeviceClock;
- float aluPerClock;
- float texPerClock;
- float primsPerClock;
- float pixelsPerClock;
-} VkPhysicalDevicePerformance;
+ VkQueueFlags queueFlags;
+ uint32_t queueCount;
+ VkBool32 supportsTimestamps;
+} VkPhysicalDeviceQueueProperties;
typedef struct {
- VkPhysicalDeviceCompatibilityFlags compatibilityFlags;
-} VkPhysicalDeviceCompatibilityInfo;
+ VkMemoryPropertyFlags propertyFlags;
+ uint32_t heapIndex;
+} VkMemoryType;
typedef struct {
- VkQueueFlags queueFlags;
- uint32_t queueCount;
- bool32_t supportsTimestamps;
-} VkPhysicalDeviceQueueProperties;
+ VkDeviceSize size;
+ VkMemoryHeapFlags flags;
+} VkMemoryHeap;
typedef struct {
- bool32_t supportsMigration;
- bool32_t supportsPinning;
+ uint32_t memoryTypeCount;
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
} VkPhysicalDeviceMemoryProperties;
typedef void (VKAPI *PFN_vkVoidFunction)(void);
const void* pNext;
uint32_t queueRecordCount;
const VkDeviceQueueCreateInfo* pRequestedQueues;
+ uint32_t layerCount;
+ const char*const* ppEnabledLayerNames;
uint32_t extensionCount;
const char*const* ppEnabledExtensionNames;
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
VkDeviceCreateFlags flags;
} VkDeviceCreateInfo;
typedef struct {
char extName[VK_MAX_EXTENSION_NAME];
- uint32_t version;
+ uint32_t specVersion;
} VkExtensionProperties;
+typedef struct {
+ char layerName[VK_MAX_EXTENSION_NAME];
+ uint32_t specVersion;
+ uint32_t implVersion;
+ const char* description[VK_MAX_DESCRIPTION];
+} VkLayerProperties;
+
typedef struct {
VkStructureType sType;
const void* pNext;
VkDeviceSize allocationSize;
- VkMemoryPropertyFlags memProps;
+ uint32_t memoryTypeIndex;
} VkMemoryAllocInfo;
typedef struct {
VkDeviceSize size;
VkDeviceSize alignment;
VkDeviceSize granularity;
- VkMemoryPropertyFlags memPropsAllowed;
- VkMemoryPropertyFlags memPropsRequired;
+ uint32_t memoryTypeBits;
} VkMemoryRequirements;
typedef struct {
VkFormat format;
VkChannelMapping channels;
VkImageSubresourceRange subresourceRange;
- float minLod;
} VkImageViewCreateInfo;
typedef struct {
uint32_t mipLevel;
uint32_t baseArraySlice;
uint32_t arraySize;
- VkImage msaaResolveImage;
- VkImageSubresourceRange msaaResolveSubResource;
-} VkColorAttachmentViewCreateInfo;
+ VkAttachmentViewCreateFlags flags;
+} VkAttachmentViewCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkImage image;
- uint32_t mipLevel;
- uint32_t baseArraySlice;
- uint32_t arraySize;
- VkImage msaaResolveImage;
- VkImageSubresourceRange msaaResolveSubResource;
- VkDepthStencilViewCreateFlags flags;
-} VkDepthStencilViewCreateInfo;
+ size_t codeSize;
+ const void* pCode;
+ VkShaderModuleCreateFlags flags;
+} VkShaderModuleCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- size_t codeSize;
- const void* pCode;
+ VkShaderModule module;
+ const char* pName;
VkShaderCreateFlags flags;
} VkShaderCreateInfo;
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ size_t initialSize;
+ const void* initialData;
+ size_t maxSize;
+} VkPipelineCacheCreateInfo;
+
typedef struct {
uint32_t constantId;
uint32_t offset;
} VkSpecializationMapEntry;
-typedef struct {
- uint32_t bufferId;
- size_t bufferSize;
- const void* pBufferData;
-} VkLinkConstBuffer;
-
typedef struct {
uint32_t mapEntryCount;
const VkSpecializationMapEntry* pMap;
} VkSpecializationInfo;
typedef struct {
+ VkStructureType sType;
+ const void* pNext;
VkShaderStage stage;
VkShader shader;
- uint32_t linkConstBufferCount;
- const VkLinkConstBuffer* pLinkConstBufferInfo;
const VkSpecializationInfo* pSpecializationInfo;
-} VkPipelineShader;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkPipelineShader shader;
} VkPipelineShaderStageCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkPrimitiveTopology topology;
- bool32_t primitiveRestartEnable;
+ VkBool32 primitiveRestartEnable;
} VkPipelineIaStateCreateInfo;
typedef struct {
typedef struct {
VkStructureType sType;
const void* pNext;
- bool32_t depthClipEnable;
- bool32_t rasterizerDiscardEnable;
+ VkBool32 depthClipEnable;
+ VkBool32 rasterizerDiscardEnable;
VkFillMode fillMode;
VkCullMode cullMode;
VkFrontFace frontFace;
typedef struct {
VkStructureType sType;
const void* pNext;
- uint32_t samples;
- bool32_t multisampleEnable;
- bool32_t sampleShadingEnable;
+ uint32_t rasterSamples;
+ VkBool32 sampleShadingEnable;
float minSampleShading;
VkSampleMask sampleMask;
} VkPipelineMsStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkFormat format;
- bool32_t depthTestEnable;
- bool32_t depthWriteEnable;
+ VkBool32 depthTestEnable;
+ VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
- bool32_t depthBoundsEnable;
- bool32_t stencilTestEnable;
+ VkBool32 depthBoundsEnable;
+ VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
} VkPipelineDsStateCreateInfo;
typedef struct {
- bool32_t blendEnable;
- VkFormat format;
+ VkBool32 blendEnable;
VkBlend srcBlendColor;
VkBlend destBlendColor;
VkBlendOp blendOpColor;
typedef struct {
VkStructureType sType;
const void* pNext;
- bool32_t alphaToCoverageEnable;
- bool32_t logicOpEnable;
+ VkBool32 alphaToCoverageEnable;
+ VkBool32 logicOpEnable;
VkLogicOp logicOp;
uint32_t attachmentCount;
const VkPipelineCbAttachmentState* pAttachments;
typedef struct {
VkStructureType sType;
const void* pNext;
+ uint32_t stageCount;
+ const VkPipelineShaderStageCreateInfo* pStages;
+ const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ const VkPipelineIaStateCreateInfo* pIaState;
+ const VkPipelineTessStateCreateInfo* pTessState;
+ const VkPipelineVpStateCreateInfo* pVpState;
+ const VkPipelineRsStateCreateInfo* pRsState;
+ const VkPipelineMsStateCreateInfo* pMsState;
+ const VkPipelineDsStateCreateInfo* pDsState;
+ const VkPipelineCbStateCreateInfo* pCbState;
VkPipelineCreateFlags flags;
VkPipelineLayout layout;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkPipeline basePipelineHandle;
+ int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkPipelineShader cs;
+ VkPipelineShaderStageCreateInfo cs;
VkPipelineCreateFlags flags;
VkPipelineLayout layout;
+ VkPipeline basePipelineHandle;
+ int32_t basePipelineIndex;
} VkComputePipelineCreateInfo;
+typedef struct {
+ VkShaderStageFlags stageFlags;
+ uint32_t start;
+ uint32_t length;
+} VkPushConstantRange;
+
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const VkPushConstantRange* pPushConstantRanges;
} VkPipelineLayoutCreateInfo;
typedef struct {
VkTexAddress addressV;
VkTexAddress addressW;
float mipLodBias;
- uint32_t maxAnisotropy;
- bool32_t compareEnable;
+ float maxAnisotropy;
+ VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
const VkDescriptorTypeCount* pTypeCount;
} VkDescriptorPoolCreateInfo;
+typedef struct {
+ VkBufferView bufferView;
+ VkSampler sampler;
+ VkImageView imageView;
+ VkAttachmentView attachmentView;
+ VkImageLayout imageLayout;
+} VkDescriptorInfo;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet destSet;
+ uint32_t destBinding;
+ uint32_t destArrayElement;
+ uint32_t count;
+ VkDescriptorType descriptorType;
+ const VkDescriptorInfo* pDescriptors;
+} VkWriteDescriptorSet;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet srcSet;
+ uint32_t srcBinding;
+ uint32_t srcArrayElement;
+ VkDescriptorSet destSet;
+ uint32_t destBinding;
+ uint32_t destArrayElement;
+ uint32_t count;
+} VkCopyDescriptorSet;
+
typedef struct {
float originX;
float originY;
uint32_t viewportAndScissorCount;
const VkViewport* pViewports;
const VkRect2D* pScissors;
-} VkDynamicVpStateCreateInfo;
+} VkDynamicViewportStateCreateInfo;
typedef struct {
VkStructureType sType;
float depthBiasClamp;
float slopeScaledDepthBias;
float lineWidth;
-} VkDynamicRsStateCreateInfo;
+} VkDynamicRasterStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
float blendConst[4];
-} VkDynamicCbStateCreateInfo;
+} VkDynamicColorBlendStateCreateInfo;
typedef struct {
VkStructureType sType;
uint32_t stencilWriteMask;
uint32_t stencilFrontRef;
uint32_t stencilBackRef;
-} VkDynamicDsStateCreateInfo;
-
-typedef struct {
- VkColorAttachmentView view;
- VkImageLayout layout;
-} VkColorAttachmentBindInfo;
+} VkDynamicDepthStencilStateCreateInfo;
typedef struct {
- VkDepthStencilView view;
+ VkAttachmentView view;
VkImageLayout layout;
-} VkDepthStencilBindInfo;
+} VkAttachmentBindInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- uint32_t colorAttachmentCount;
- const VkColorAttachmentBindInfo* pColorAttachments;
- const VkDepthStencilBindInfo* pDepthStencilAttachment;
- uint32_t sampleCount;
+ VkRenderPass renderPass;
+ uint32_t attachmentCount;
+ const VkAttachmentBindInfo* pAttachments;
uint32_t width;
uint32_t height;
uint32_t layers;
} VkFramebufferCreateInfo;
-typedef union {
- float f32[4];
- int32_t s32[4];
- uint32_t u32[4];
-} VkClearColorValue;
-
typedef struct {
VkStructureType sType;
const void* pNext;
- VkRect2D renderArea;
- uint32_t colorAttachmentCount;
- VkExtent2D extent;
- uint32_t sampleCount;
- uint32_t layers;
- const VkFormat* pColorFormats;
- const VkImageLayout* pColorLayouts;
- const VkAttachmentLoadOp* pColorLoadOps;
- const VkAttachmentStoreOp* pColorStoreOps;
- const VkClearColorValue* pColorLoadClearValues;
- VkFormat depthStencilFormat;
- VkImageLayout depthStencilLayout;
- VkAttachmentLoadOp depthLoadOp;
- float depthLoadClearValue;
- VkAttachmentStoreOp depthStoreOp;
+ VkFormat format;
+ uint32_t samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
VkAttachmentLoadOp stencilLoadOp;
- uint32_t stencilLoadClearValue;
VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+} VkAttachmentDescription;
+
+typedef struct {
+ uint32_t attachment;
+ VkImageLayout layout;
+} VkAttachmentReference;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineBindPoint pipelineBindPoint;
+ VkSubpassDescriptionFlags flags;
+ uint32_t inputCount;
+ const VkAttachmentReference* inputAttachments;
+ uint32_t colorCount;
+ const VkAttachmentReference* colorAttachments;
+ const VkAttachmentReference* resolveAttachments;
+ VkAttachmentReference depthStencilAttachment;
+ uint32_t preserveCount;
+ const VkAttachmentReference* preserveAttachments;
+} VkSubpassDescription;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags destStageMask;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkBool32 byRegion;
+} VkSubpassDependency;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t attachmentCount;
+ const VkAttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+ const VkSubpassDescription* pSubpasses;
+ uint32_t dependencyCount;
+ const VkSubpassDependency* pDependencies;
} VkRenderPassCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t queueNodeIndex;
+ VkCmdBufferLevel level;
VkCmdBufferCreateFlags flags;
} VkCmdBufferCreateInfo;
VkStructureType sType;
const void* pNext;
VkCmdBufferOptimizeFlags flags;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
} VkCmdBufferBeginInfo;
typedef struct {
typedef struct {
VkDeviceSize bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
VkImageSubresource imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkBufferImageCopy;
+typedef union {
+ float f32[4];
+ int32_t s32[4];
+ uint32_t u32[4];
+} VkClearColorValue;
+
typedef struct {
VkOffset3D offset;
VkExtent3D extent;
} VkImageResolve;
typedef struct {
+ float depth;
+ uint32_t stencil;
+} VkClearDepthStencilValue;
+
+typedef union {
+ VkClearColorValue color;
+ VkClearDepthStencilValue ds;
+} VkClearValue;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
-} VkRenderPassBegin;
+ VkRect2D renderArea;
+ uint32_t attachmentCount;
+ const VkClearValue* pAttachmentClearValues;
+} VkRenderPassBeginInfo;
typedef struct {
VkStructureType sType;
VkImageSubresourceRange subresourceRange;
} VkImageMemoryBarrier;
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- uint32_t layerCount;
- const char *const* ppActiveLayerNames;
-} VkLayerCreateInfo;
-
typedef struct {
VkStructureType sType;
const void* pNext;
VkMemoryInputFlags inputMask;
} VkMemoryBarrier;
-typedef struct {
- VkFormatFeatureFlags linearTilingFeatures;
- VkFormatFeatureFlags optimalTilingFeatures;
-} VkFormatProperties;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkBufferView view;
-} VkBufferViewAttachInfo;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkImageView view;
- VkImageLayout layout;
-} VkImageViewAttachInfo;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- uint32_t binding;
- uint32_t arrayIndex;
- uint32_t count;
- const VkSampler* pSamplers;
-} VkUpdateSamplers;
-
-typedef struct {
- VkSampler sampler;
- const VkImageViewAttachInfo* pImageView;
-} VkSamplerImageViewInfo;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- uint32_t binding;
- uint32_t arrayIndex;
- uint32_t count;
- const VkSamplerImageViewInfo* pSamplerImageViews;
-} VkUpdateSamplerTextures;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkDescriptorType descriptorType;
- uint32_t binding;
- uint32_t arrayIndex;
- uint32_t count;
- const VkImageViewAttachInfo* pImageViews;
-} VkUpdateImages;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkDescriptorType descriptorType;
- uint32_t binding;
- uint32_t arrayIndex;
- uint32_t count;
- const VkBufferViewAttachInfo* pBufferViews;
-} VkUpdateBuffers;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
- VkDescriptorType descriptorType;
- VkDescriptorSet descriptorSet;
- uint32_t binding;
- uint32_t arrayElement;
- uint32_t count;
-} VkUpdateAsCopy;
-
-typedef struct {
- VkStructureType sType;
- const void* pNext;
-
- VkRenderPassBegin renderPassContinue;
-} VkCmdBufferGraphicsBeginInfo;
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, VkPhysicalDevice* pPhysicalDevices);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatInfo)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatInfo);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperies);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, 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_vkGetGlobalExtensionCount)(uint32_t* pCount);
-typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(uint32_t extensionIndex, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, uint32_t extensionIndex, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved);
+typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
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_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
-typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkGetObjectMemoryRequirements)(VkDevice device, VkObjectType objType, VkObject object, VkMemoryRequirements* pMemoryRequirements);
+typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
+typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
-typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout);
+typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
-typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
+typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
+typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView);
+typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView);
+typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
-typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline);
-typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline);
+typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
+typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
+typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
+typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
+typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
+typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount);
-typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDevice device, 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);
-typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState);
+typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState);
typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
+typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
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 dynamicState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
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_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_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter);
typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects);
typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects);
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, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, VkPipeEventFlags pipeEventMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, VkPipeEventFlags pipeEventMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* 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, VkDeviceSize destOffset);
typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
+typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
-VkResult VKAPI vkGetPhysicalDeviceInfo(
+VkResult VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceInfoType infoType,
- size_t* pDataSize,
- void* pData);
+ VkPhysicalDeviceFeatures* pFeatures);
VkResult VKAPI vkGetPhysicalDeviceFormatInfo(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatInfo);
+VkResult VKAPI vkGetPhysicalDeviceLimits(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceLimits* pLimits);
+
+VkResult VKAPI vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+
+VkResult VKAPI vkGetPhysicalDeviceQueueCount(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pCount);
+
+VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t count,
+ VkPhysicalDeviceQueueProperties* pQueueProperties);
+
+VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperies);
+
PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(
VkInstance instance,
const char* pName);
VkResult VKAPI vkDestroyDevice(
VkDevice device);
-VkResult VKAPI vkGetGlobalExtensionCount(
- uint32_t* pCount);
-
VkResult VKAPI vkGetGlobalExtensionProperties(
- uint32_t extensionIndex,
+ const char* pLayerName,
+ uint32_t* pCount,
VkExtensionProperties* pProperties);
-VkResult VKAPI vkGetPhysicalDeviceExtensionCount(
- VkPhysicalDevice physicalDevice,
- uint32_t* pCount);
-
VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
- uint32_t extensionIndex,
+ const char* pLayerName,
+ uint32_t* pCount,
VkExtensionProperties* pProperties);
-VkResult VKAPI vkEnumerateLayers(
+VkResult VKAPI vkGetGlobalLayerProperties(
+ uint32_t* pCount,
+ VkLayerProperties* pProperties);
+
+VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
- size_t maxStringSize,
- size_t* pLayerCount,
- char* const* pOutLayers,
- void* pReserved);
+ uint32_t* pCount,
+ VkLayerProperties* pProperties);
VkResult VKAPI vkGetDeviceQueue(
VkDevice device,
VkObjectType objType,
VkObject object);
-VkResult VKAPI vkBindObjectMemory(
+VkResult VKAPI vkBindBufferMemory(
VkDevice device,
- VkObjectType objType,
- VkObject object,
+ VkBuffer buffer,
VkDeviceMemory mem,
VkDeviceSize memOffset);
-VkResult VKAPI vkGetObjectMemoryRequirements(
+VkResult VKAPI vkBindImageMemory(
VkDevice device,
- VkObjectType objType,
- VkObject object,
+ VkImage image,
+ VkDeviceMemory mem,
+ VkDeviceSize memOffset);
+
+VkResult VKAPI vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+
+VkResult VKAPI vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
VkMemoryRequirements* pMemoryRequirements);
VkResult VKAPI vkQueueBindSparseBufferMemory(
const VkFenceCreateInfo* pCreateInfo,
VkFence* pFence);
+VkResult VKAPI vkDestroyFence(
+ VkDevice device,
+ VkFence fence);
+
VkResult VKAPI vkResetFences(
VkDevice device,
uint32_t fenceCount,
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
- bool32_t waitAll,
+ VkBool32 waitAll,
uint64_t timeout);
VkResult VKAPI vkCreateSemaphore(
const VkSemaphoreCreateInfo* pCreateInfo,
VkSemaphore* pSemaphore);
+VkResult VKAPI vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore);
+
VkResult VKAPI vkQueueSignalSemaphore(
VkQueue queue,
VkSemaphore semaphore);
const VkEventCreateInfo* pCreateInfo,
VkEvent* pEvent);
+VkResult VKAPI vkDestroyEvent(
+ VkDevice device,
+ VkEvent event);
+
VkResult VKAPI vkGetEventStatus(
VkDevice device,
VkEvent event);
const VkQueryPoolCreateInfo* pCreateInfo,
VkQueryPool* pQueryPool);
+VkResult VKAPI vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool);
+
VkResult VKAPI vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
const VkBufferCreateInfo* pCreateInfo,
VkBuffer* pBuffer);
+VkResult VKAPI vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer);
+
VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
VkBufferView* pView);
+VkResult VKAPI vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView);
+
VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
VkImage* pImage);
+VkResult VKAPI vkDestroyImage(
+ VkDevice device,
+ VkImage image);
+
VkResult VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageViewCreateInfo* pCreateInfo,
VkImageView* pView);
-VkResult VKAPI vkCreateColorAttachmentView(
+VkResult VKAPI vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView);
+
+VkResult VKAPI vkCreateAttachmentView(
VkDevice device,
- const VkColorAttachmentViewCreateInfo* pCreateInfo,
- VkColorAttachmentView* pView);
+ const VkAttachmentViewCreateInfo* pCreateInfo,
+ VkAttachmentView* pView);
-VkResult VKAPI vkCreateDepthStencilView(
+VkResult VKAPI vkDestroyAttachmentView(
VkDevice device,
- const VkDepthStencilViewCreateInfo* pCreateInfo,
- VkDepthStencilView* pView);
+ VkAttachmentView attachmentView);
+
+VkResult VKAPI vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ VkShaderModule* pShaderModule);
+
+VkResult VKAPI vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule);
VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
VkShader* pShader);
-VkResult VKAPI vkCreateGraphicsPipeline(
+VkResult VKAPI vkDestroyShader(
VkDevice device,
- const VkGraphicsPipelineCreateInfo* pCreateInfo,
- VkPipeline* pPipeline);
+ VkShader shader);
-VkResult VKAPI vkCreateGraphicsPipelineDerivative(
+VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
- const VkGraphicsPipelineCreateInfo* pCreateInfo,
- VkPipeline basePipeline,
- VkPipeline* pPipeline);
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ VkPipelineCache* pPipelineCache);
-VkResult VKAPI vkCreateComputePipeline(
+VkResult VKAPI vkDestroyPipelineCache(
VkDevice device,
- const VkComputePipelineCreateInfo* pCreateInfo,
- VkPipeline* pPipeline);
+ VkPipelineCache pipelineCache);
-VkResult VKAPI vkStorePipeline(
+size_t VKAPI vkGetPipelineCacheSize(
VkDevice device,
- VkPipeline pipeline,
- size_t* pDataSize,
+ VkPipelineCache pipelineCache);
+
+VkResult VKAPI vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
void* pData);
-VkResult VKAPI vkLoadPipeline(
+VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
- size_t dataSize,
- const void* pData,
- VkPipeline* pPipeline);
+ VkPipelineCache destCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
-VkResult VKAPI vkLoadPipelineDerivative(
+VkResult VKAPI vkCreateGraphicsPipelines(
VkDevice device,
- size_t dataSize,
- const void* pData,
- VkPipeline basePipeline,
- VkPipeline* pPipeline);
+ VkPipelineCache pipelineCache,
+ uint32_t count,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ VkPipeline* pPipelines);
+
+VkResult VKAPI vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t count,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ VkPipeline* pPipelines);
+
+VkResult VKAPI vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline);
VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
VkPipelineLayout* pPipelineLayout);
+VkResult VKAPI vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout);
+
VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
VkSampler* pSampler);
+VkResult VKAPI vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler);
+
VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayout* pSetLayout);
+VkResult VKAPI vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout);
+
VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
VkDescriptorPoolUsage poolUsage,
const VkDescriptorPoolCreateInfo* pCreateInfo,
VkDescriptorPool* pDescriptorPool);
+VkResult VKAPI vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool);
+
VkResult VKAPI vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool);
VkDescriptorSet* pDescriptorSets,
uint32_t* pCount);
-void VKAPI vkUpdateDescriptors(
+VkResult VKAPI vkUpdateDescriptorSets(
VkDevice device,
- VkDescriptorSet descriptorSet,
- uint32_t updateCount,
- const void** ppUpdateArray);
+ uint32_t writeCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t copyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
VkResult VKAPI vkCreateDynamicViewportState(
VkDevice device,
- const VkDynamicVpStateCreateInfo* pCreateInfo,
- VkDynamicVpState* pState);
+ const VkDynamicViewportStateCreateInfo* pCreateInfo,
+ VkDynamicViewportState* pState);
+
+VkResult VKAPI vkDestroyDynamicViewportState(
+ VkDevice device,
+ VkDynamicViewportState dynamicViewportState);
VkResult VKAPI vkCreateDynamicRasterState(
VkDevice device,
- const VkDynamicRsStateCreateInfo* pCreateInfo,
- VkDynamicRsState* pState);
+ const VkDynamicRasterStateCreateInfo* pCreateInfo,
+ VkDynamicRasterState* pState);
+
+VkResult VKAPI vkDestroyDynamicRasterState(
+ VkDevice device,
+ VkDynamicRasterState dynamicRasterState);
VkResult VKAPI vkCreateDynamicColorBlendState(
VkDevice device,
- const VkDynamicCbStateCreateInfo* pCreateInfo,
- VkDynamicCbState* pState);
+ const VkDynamicColorBlendStateCreateInfo* pCreateInfo,
+ VkDynamicColorBlendState* pState);
+
+VkResult VKAPI vkDestroyDynamicColorBlendState(
+ VkDevice device,
+ VkDynamicColorBlendState dynamicColorBlendState);
VkResult VKAPI vkCreateDynamicDepthStencilState(
VkDevice device,
- const VkDynamicDsStateCreateInfo* pCreateInfo,
- VkDynamicDsState* pState);
+ const VkDynamicDepthStencilStateCreateInfo* pCreateInfo,
+ VkDynamicDepthStencilState* pState);
+
+VkResult VKAPI vkDestroyDynamicDepthStencilState(
+ VkDevice device,
+ VkDynamicDepthStencilState dynamicDepthStencilState);
VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
VkFramebuffer* pFramebuffer);
+VkResult VKAPI vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer);
+
VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
VkRenderPass* pRenderPass);
+VkResult VKAPI vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass);
+
VkResult VKAPI vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
const VkCmdBufferCreateInfo* pCreateInfo,
VkCmdBuffer* pCmdBuffer);
+VkResult VKAPI vkDestroyCommandBuffer(
+ VkDevice device,
+ VkCmdBuffer commandBuffer);
+
VkResult VKAPI vkBeginCommandBuffer(
VkCmdBuffer cmdBuffer,
const VkCmdBufferBeginInfo* pBeginInfo);
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline);
-void VKAPI vkCmdBindDynamicStateObject(
+void VKAPI vkCmdBindDynamicViewportState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicViewportState dynamicViewportState);
+
+void VKAPI vkCmdBindDynamicRasterState(
VkCmdBuffer cmdBuffer,
- VkStateBindPoint stateBindPoint,
- VkDynamicStateObject dynamicState);
+ VkDynamicRasterState dynamicRasterState);
+
+void VKAPI vkCmdBindDynamicColorBlendState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicColorBlendState dynamicColorBlendState);
+
+void VKAPI vkCmdBindDynamicDepthStencilState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicDepthStencilState dynamicDepthStencilState);
void VKAPI vkCmdBindDescriptorSets(
VkCmdBuffer cmdBuffer,
VkImage destImage,
VkImageLayout destImageLayout,
uint32_t regionCount,
- const VkImageBlit* pRegions);
+ const VkImageBlit* pRegions,
+ VkTexFilter filter);
void VKAPI vkCmdCopyBufferToImage(
VkCmdBuffer cmdBuffer,
void VKAPI vkCmdSetEvent(
VkCmdBuffer cmdBuffer,
VkEvent event,
- VkPipeEvent pipeEvent);
+ VkPipelineStageFlags stageMask);
void VKAPI vkCmdResetEvent(
VkCmdBuffer cmdBuffer,
VkEvent event,
- VkPipeEvent pipeEvent);
+ VkPipelineStageFlags stageMask);
void VKAPI vkCmdWaitEvents(
VkCmdBuffer cmdBuffer,
- VkWaitEvent waitEvent,
uint32_t eventCount,
const VkEvent* pEvents,
- VkPipeEventFlags pipeEventMask,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags destStageMask,
uint32_t memBarrierCount,
const void* const* ppMemBarriers);
void VKAPI vkCmdPipelineBarrier(
VkCmdBuffer cmdBuffer,
- VkWaitEvent waitEvent,
- VkPipeEventFlags pipeEventMask,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags destStageMask,
+ VkBool32 byRegion,
uint32_t memBarrierCount,
const void* const* ppMemBarriers);
void VKAPI vkCmdBeginRenderPass(
VkCmdBuffer cmdBuffer,
- const VkRenderPassBegin* pRenderPassBegin);
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkRenderPassContents contents);
+
+void VKAPI vkCmdNextSubpass(
+ VkCmdBuffer cmdBuffer,
+ VkRenderPassContents contents);
void VKAPI vkCmdEndRenderPass(
VkCmdBuffer cmdBuffer);