OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2a9136feb46b2491e9d93c7980bc69bed7eae6a8
third_party_mesa3d/include/vulkan/vulkan.h
Jason Ekstrand 2a9136feb4 vk/image: Add a stub for the new ImageFormatProperties function 
This lets the client query about things like multisample.  We don't do
multisample right now, so I'll let Chad deal with that when he gets to it.
2015-07-14 17:05:30 -07:00

2929 lines
137 KiB
C
Raw Blame History

#ifndef __vulkan_h_
#define __vulkan_h_ 1
#ifdef __cplusplus
extern "C" {
#endif
/*
** Copyright (c) 2015 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** 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, 131, 0)
#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
#define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
#endif
#if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES)
#define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj;
#define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
#define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj)
#define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
#define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
#else
#define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj;
#define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj;
#define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj;
#endif
#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
#define VK_MAX_PHYSICAL_DEVICE_NAME 256
#define VK_UUID_LENGTH 16
#define VK_MAX_MEMORY_TYPES 32
#define VK_MAX_MEMORY_HEAPS 16
#define VK_MAX_EXTENSION_NAME 256
#define VK_MAX_DESCRIPTION 256
VK_DEFINE_BASE_HANDLE(VkObject)
VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject)
VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject)
VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject)
VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject)
VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable)
VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable)
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(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(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)
typedef enum {
VK_SUCCESS = 0,
VK_UNSUPPORTED = 1,
VK_NOT_READY = 2,
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_OUT_OF_HOST_MEMORY = -4,
VK_ERROR_OUT_OF_DEVICE_MEMORY = -5,
VK_ERROR_DEVICE_ALREADY_CREATED = -6,
VK_ERROR_DEVICE_LOST = -7,
VK_ERROR_INVALID_POINTER = -8,
VK_ERROR_INVALID_VALUE = -9,
VK_ERROR_INVALID_HANDLE = -10,
VK_ERROR_INVALID_ORDINAL = -11,
VK_ERROR_INVALID_MEMORY_SIZE = -12,
VK_ERROR_INVALID_EXTENSION = -13,
VK_ERROR_INVALID_FLAGS = -14,
VK_ERROR_INVALID_ALIGNMENT = -15,
VK_ERROR_INVALID_FORMAT = -16,
VK_ERROR_INVALID_IMAGE = -17,
VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18,
VK_ERROR_INVALID_QUEUE_TYPE = -19,
VK_ERROR_INVALID_OBJECT_TYPE = -20,
VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -21,
VK_ERROR_BAD_SHADER_CODE = -22,
VK_ERROR_BAD_PIPELINE_DATA = -23,
VK_ERROR_NOT_MAPPABLE = -24,
VK_ERROR_MEMORY_MAP_FAILED = -25,
VK_ERROR_MEMORY_UNMAP_FAILED = -26,
VK_ERROR_INCOMPATIBLE_DEVICE = -27,
VK_ERROR_INCOMPATIBLE_DRIVER = -28,
VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -29,
VK_ERROR_BUILDING_COMMAND_BUFFER = -30,
VK_ERROR_MEMORY_NOT_BOUND = -31,
VK_ERROR_INCOMPATIBLE_QUEUE = -32,
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;
typedef enum {
VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
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_VIEWPORT_STATE_CREATE_INFO = 10,
VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11,
VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12,
VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_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_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22,
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24,
VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25,
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26,
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_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_SYSTEM_ALLOC_TYPE_API_OBJECT = 0,
VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1,
VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2,
VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3,
VK_SYSTEM_ALLOC_TYPE_DEBUG = 4,
VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT,
VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG,
VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1),
VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkSystemAllocType;
typedef enum {
VK_FORMAT_UNDEFINED = 0,
VK_FORMAT_R4G4_UNORM = 1,
VK_FORMAT_R4G4_USCALED = 2,
VK_FORMAT_R4G4B4A4_UNORM = 3,
VK_FORMAT_R4G4B4A4_USCALED = 4,
VK_FORMAT_R5G6B5_UNORM = 5,
VK_FORMAT_R5G6B5_USCALED = 6,
VK_FORMAT_R5G5B5A1_UNORM = 7,
VK_FORMAT_R5G5B5A1_USCALED = 8,
VK_FORMAT_R8_UNORM = 9,
VK_FORMAT_R8_SNORM = 10,
VK_FORMAT_R8_USCALED = 11,
VK_FORMAT_R8_SSCALED = 12,
VK_FORMAT_R8_UINT = 13,
VK_FORMAT_R8_SINT = 14,
VK_FORMAT_R8_SRGB = 15,
VK_FORMAT_R8G8_UNORM = 16,
VK_FORMAT_R8G8_SNORM = 17,
VK_FORMAT_R8G8_USCALED = 18,
VK_FORMAT_R8G8_SSCALED = 19,
VK_FORMAT_R8G8_UINT = 20,
VK_FORMAT_R8G8_SINT = 21,
VK_FORMAT_R8G8_SRGB = 22,
VK_FORMAT_R8G8B8_UNORM = 23,
VK_FORMAT_R8G8B8_SNORM = 24,
VK_FORMAT_R8G8B8_USCALED = 25,
VK_FORMAT_R8G8B8_SSCALED = 26,
VK_FORMAT_R8G8B8_UINT = 27,
VK_FORMAT_R8G8B8_SINT = 28,
VK_FORMAT_R8G8B8_SRGB = 29,
VK_FORMAT_R8G8B8A8_UNORM = 30,
VK_FORMAT_R8G8B8A8_SNORM = 31,
VK_FORMAT_R8G8B8A8_USCALED = 32,
VK_FORMAT_R8G8B8A8_SSCALED = 33,
VK_FORMAT_R8G8B8A8_UINT = 34,
VK_FORMAT_R8G8B8A8_SINT = 35,
VK_FORMAT_R8G8B8A8_SRGB = 36,
VK_FORMAT_R10G10B10A2_UNORM = 37,
VK_FORMAT_R10G10B10A2_SNORM = 38,
VK_FORMAT_R10G10B10A2_USCALED = 39,
VK_FORMAT_R10G10B10A2_SSCALED = 40,
VK_FORMAT_R10G10B10A2_UINT = 41,
VK_FORMAT_R10G10B10A2_SINT = 42,
VK_FORMAT_R16_UNORM = 43,
VK_FORMAT_R16_SNORM = 44,
VK_FORMAT_R16_USCALED = 45,
VK_FORMAT_R16_SSCALED = 46,
VK_FORMAT_R16_UINT = 47,
VK_FORMAT_R16_SINT = 48,
VK_FORMAT_R16_SFLOAT = 49,
VK_FORMAT_R16G16_UNORM = 50,
VK_FORMAT_R16G16_SNORM = 51,
VK_FORMAT_R16G16_USCALED = 52,
VK_FORMAT_R16G16_SSCALED = 53,
VK_FORMAT_R16G16_UINT = 54,
VK_FORMAT_R16G16_SINT = 55,
VK_FORMAT_R16G16_SFLOAT = 56,
VK_FORMAT_R16G16B16_UNORM = 57,
VK_FORMAT_R16G16B16_SNORM = 58,
VK_FORMAT_R16G16B16_USCALED = 59,
VK_FORMAT_R16G16B16_SSCALED = 60,
VK_FORMAT_R16G16B16_UINT = 61,
VK_FORMAT_R16G16B16_SINT = 62,
VK_FORMAT_R16G16B16_SFLOAT = 63,
VK_FORMAT_R16G16B16A16_UNORM = 64,
VK_FORMAT_R16G16B16A16_SNORM = 65,
VK_FORMAT_R16G16B16A16_USCALED = 66,
VK_FORMAT_R16G16B16A16_SSCALED = 67,
VK_FORMAT_R16G16B16A16_UINT = 68,
VK_FORMAT_R16G16B16A16_SINT = 69,
VK_FORMAT_R16G16B16A16_SFLOAT = 70,
VK_FORMAT_R32_UINT = 71,
VK_FORMAT_R32_SINT = 72,
VK_FORMAT_R32_SFLOAT = 73,
VK_FORMAT_R32G32_UINT = 74,
VK_FORMAT_R32G32_SINT = 75,
VK_FORMAT_R32G32_SFLOAT = 76,
VK_FORMAT_R32G32B32_UINT = 77,
VK_FORMAT_R32G32B32_SINT = 78,
VK_FORMAT_R32G32B32_SFLOAT = 79,
VK_FORMAT_R32G32B32A32_UINT = 80,
VK_FORMAT_R32G32B32A32_SINT = 81,
VK_FORMAT_R32G32B32A32_SFLOAT = 82,
VK_FORMAT_R64_SFLOAT = 83,
VK_FORMAT_R64G64_SFLOAT = 84,
VK_FORMAT_R64G64B64_SFLOAT = 85,
VK_FORMAT_R64G64B64A64_SFLOAT = 86,
VK_FORMAT_R11G11B10_UFLOAT = 87,
VK_FORMAT_R9G9B9E5_UFLOAT = 88,
VK_FORMAT_D16_UNORM = 89,
VK_FORMAT_D24_UNORM = 90,
VK_FORMAT_D32_SFLOAT = 91,
VK_FORMAT_S8_UINT = 92,
VK_FORMAT_D16_UNORM_S8_UINT = 93,
VK_FORMAT_D24_UNORM_S8_UINT = 94,
VK_FORMAT_D32_SFLOAT_S8_UINT = 95,
VK_FORMAT_BC1_RGB_UNORM = 96,
VK_FORMAT_BC1_RGB_SRGB = 97,
VK_FORMAT_BC1_RGBA_UNORM = 98,
VK_FORMAT_BC1_RGBA_SRGB = 99,
VK_FORMAT_BC2_UNORM = 100,
VK_FORMAT_BC2_SRGB = 101,
VK_FORMAT_BC3_UNORM = 102,
VK_FORMAT_BC3_SRGB = 103,
VK_FORMAT_BC4_UNORM = 104,
VK_FORMAT_BC4_SNORM = 105,
VK_FORMAT_BC5_UNORM = 106,
VK_FORMAT_BC5_SNORM = 107,
VK_FORMAT_BC6H_UFLOAT = 108,
VK_FORMAT_BC6H_SFLOAT = 109,
VK_FORMAT_BC7_UNORM = 110,
VK_FORMAT_BC7_SRGB = 111,
VK_FORMAT_ETC2_R8G8B8_UNORM = 112,
VK_FORMAT_ETC2_R8G8B8_SRGB = 113,
VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114,
VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115,
VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116,
VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117,
VK_FORMAT_EAC_R11_UNORM = 118,
VK_FORMAT_EAC_R11_SNORM = 119,
VK_FORMAT_EAC_R11G11_UNORM = 120,
VK_FORMAT_EAC_R11G11_SNORM = 121,
VK_FORMAT_ASTC_4x4_UNORM = 122,
VK_FORMAT_ASTC_4x4_SRGB = 123,
VK_FORMAT_ASTC_5x4_UNORM = 124,
VK_FORMAT_ASTC_5x4_SRGB = 125,
VK_FORMAT_ASTC_5x5_UNORM = 126,
VK_FORMAT_ASTC_5x5_SRGB = 127,
VK_FORMAT_ASTC_6x5_UNORM = 128,
VK_FORMAT_ASTC_6x5_SRGB = 129,
VK_FORMAT_ASTC_6x6_UNORM = 130,
VK_FORMAT_ASTC_6x6_SRGB = 131,
VK_FORMAT_ASTC_8x5_UNORM = 132,
VK_FORMAT_ASTC_8x5_SRGB = 133,
VK_FORMAT_ASTC_8x6_UNORM = 134,
VK_FORMAT_ASTC_8x6_SRGB = 135,
VK_FORMAT_ASTC_8x8_UNORM = 136,
VK_FORMAT_ASTC_8x8_SRGB = 137,
VK_FORMAT_ASTC_10x5_UNORM = 138,
VK_FORMAT_ASTC_10x5_SRGB = 139,
VK_FORMAT_ASTC_10x6_UNORM = 140,
VK_FORMAT_ASTC_10x6_SRGB = 141,
VK_FORMAT_ASTC_10x8_UNORM = 142,
VK_FORMAT_ASTC_10x8_SRGB = 143,
VK_FORMAT_ASTC_10x10_UNORM = 144,
VK_FORMAT_ASTC_10x10_SRGB = 145,
VK_FORMAT_ASTC_12x10_UNORM = 146,
VK_FORMAT_ASTC_12x10_SRGB = 147,
VK_FORMAT_ASTC_12x12_UNORM = 148,
VK_FORMAT_ASTC_12x12_SRGB = 149,
VK_FORMAT_B4G4R4A4_UNORM = 150,
VK_FORMAT_B5G5R5A1_UNORM = 151,
VK_FORMAT_B5G6R5_UNORM = 152,
VK_FORMAT_B5G6R5_USCALED = 153,
VK_FORMAT_B8G8R8_UNORM = 154,
VK_FORMAT_B8G8R8_SNORM = 155,
VK_FORMAT_B8G8R8_USCALED = 156,
VK_FORMAT_B8G8R8_SSCALED = 157,
VK_FORMAT_B8G8R8_UINT = 158,
VK_FORMAT_B8G8R8_SINT = 159,
VK_FORMAT_B8G8R8_SRGB = 160,
VK_FORMAT_B8G8R8A8_UNORM = 161,
VK_FORMAT_B8G8R8A8_SNORM = 162,
VK_FORMAT_B8G8R8A8_USCALED = 163,
VK_FORMAT_B8G8R8A8_SSCALED = 164,
VK_FORMAT_B8G8R8A8_UINT = 165,
VK_FORMAT_B8G8R8A8_SINT = 166,
VK_FORMAT_B8G8R8A8_SRGB = 167,
VK_FORMAT_B10G10R10A2_UNORM = 168,
VK_FORMAT_B10G10R10A2_SNORM = 169,
VK_FORMAT_B10G10R10A2_USCALED = 170,
VK_FORMAT_B10G10R10A2_SSCALED = 171,
VK_FORMAT_B10G10R10A2_UINT = 172,
VK_FORMAT_B10G10R10A2_SINT = 173,
VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
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_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkPhysicalDeviceType;
typedef enum {
VK_OBJECT_TYPE_INSTANCE = 0,
VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1,
VK_OBJECT_TYPE_DEVICE = 2,
VK_OBJECT_TYPE_QUEUE = 3,
VK_OBJECT_TYPE_COMMAND_BUFFER = 4,
VK_OBJECT_TYPE_DEVICE_MEMORY = 5,
VK_OBJECT_TYPE_BUFFER = 6,
VK_OBJECT_TYPE_BUFFER_VIEW = 7,
VK_OBJECT_TYPE_IMAGE = 8,
VK_OBJECT_TYPE_IMAGE_VIEW = 9,
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_SAMPLER = 15,
VK_OBJECT_TYPE_DESCRIPTOR_SET = 16,
VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17,
VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18,
VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19,
VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20,
VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21,
VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22,
VK_OBJECT_TYPE_FENCE = 23,
VK_OBJECT_TYPE_SEMAPHORE = 24,
VK_OBJECT_TYPE_EVENT = 25,
VK_OBJECT_TYPE_QUERY_POOL = 26,
VK_OBJECT_TYPE_FRAMEBUFFER = 27,
VK_OBJECT_TYPE_RENDER_PASS = 28,
VK_OBJECT_TYPE_PIPELINE_CACHE = 29,
VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
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;
typedef enum {
VK_IMAGE_ASPECT_COLOR = 0,
VK_IMAGE_ASPECT_DEPTH = 1,
VK_IMAGE_ASPECT_STENCIL = 2,
VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR,
VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL,
VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_STENCIL - VK_IMAGE_ASPECT_COLOR + 1),
VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF
} VkImageAspect;
typedef enum {
VK_QUERY_TYPE_OCCLUSION = 0,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1),
VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkQueryType;
typedef enum {
VK_BUFFER_VIEW_TYPE_RAW = 0,
VK_BUFFER_VIEW_TYPE_FORMATTED = 1,
VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW,
VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED,
VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1),
VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkBufferViewType;
typedef enum {
VK_IMAGE_VIEW_TYPE_1D = 0,
VK_IMAGE_VIEW_TYPE_2D = 1,
VK_IMAGE_VIEW_TYPE_3D = 2,
VK_IMAGE_VIEW_TYPE_CUBE = 3,
VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageViewType;
typedef enum {
VK_CHANNEL_SWIZZLE_ZERO = 0,
VK_CHANNEL_SWIZZLE_ONE = 1,
VK_CHANNEL_SWIZZLE_R = 2,
VK_CHANNEL_SWIZZLE_G = 3,
VK_CHANNEL_SWIZZLE_B = 4,
VK_CHANNEL_SWIZZLE_A = 5,
VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO,
VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1),
VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
} VkChannelSwizzle;
typedef enum {
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_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1),
VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF
} VkShaderStage;
typedef enum {
VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
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_INSTANCE,
VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
} VkVertexInputStepRate;
typedef enum {
VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9,
VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
} VkPrimitiveTopology;
typedef enum {
VK_FILL_MODE_POINTS = 0,
VK_FILL_MODE_WIREFRAME = 1,
VK_FILL_MODE_SOLID = 2,
VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS,
VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID,
VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1),
VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
} VkFillMode;
typedef enum {
VK_CULL_MODE_NONE = 0,
VK_CULL_MODE_FRONT = 1,
VK_CULL_MODE_BACK = 2,
VK_CULL_MODE_FRONT_AND_BACK = 3,
VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE,
VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK,
VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1),
VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF
} VkCullMode;
typedef enum {
VK_FRONT_FACE_CCW = 0,
VK_FRONT_FACE_CW = 1,
VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW,
VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1),
VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
} VkFrontFace;
typedef enum {
VK_COMPARE_OP_NEVER = 0,
VK_COMPARE_OP_LESS = 1,
VK_COMPARE_OP_EQUAL = 2,
VK_COMPARE_OP_LESS_EQUAL = 3,
VK_COMPARE_OP_GREATER = 4,
VK_COMPARE_OP_NOT_EQUAL = 5,
VK_COMPARE_OP_GREATER_EQUAL = 6,
VK_COMPARE_OP_ALWAYS = 7,
VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
} VkCompareOp;
typedef enum {
VK_STENCIL_OP_KEEP = 0,
VK_STENCIL_OP_ZERO = 1,
VK_STENCIL_OP_REPLACE = 2,
VK_STENCIL_OP_INC_CLAMP = 3,
VK_STENCIL_OP_DEC_CLAMP = 4,
VK_STENCIL_OP_INVERT = 5,
VK_STENCIL_OP_INC_WRAP = 6,
VK_STENCIL_OP_DEC_WRAP = 7,
VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1),
VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
} VkStencilOp;
typedef enum {
VK_LOGIC_OP_CLEAR = 0,
VK_LOGIC_OP_AND = 1,
VK_LOGIC_OP_AND_REVERSE = 2,
VK_LOGIC_OP_COPY = 3,
VK_LOGIC_OP_AND_INVERTED = 4,
VK_LOGIC_OP_NOOP = 5,
VK_LOGIC_OP_XOR = 6,
VK_LOGIC_OP_OR = 7,
VK_LOGIC_OP_NOR = 8,
VK_LOGIC_OP_EQUIV = 9,
VK_LOGIC_OP_INVERT = 10,
VK_LOGIC_OP_OR_REVERSE = 11,
VK_LOGIC_OP_COPY_INVERTED = 12,
VK_LOGIC_OP_OR_INVERTED = 13,
VK_LOGIC_OP_NAND = 14,
VK_LOGIC_OP_SET = 15,
VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
} VkLogicOp;
typedef enum {
VK_BLEND_ZERO = 0,
VK_BLEND_ONE = 1,
VK_BLEND_SRC_COLOR = 2,
VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
VK_BLEND_DEST_COLOR = 4,
VK_BLEND_ONE_MINUS_DEST_COLOR = 5,
VK_BLEND_SRC_ALPHA = 6,
VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
VK_BLEND_DEST_ALPHA = 8,
VK_BLEND_ONE_MINUS_DEST_ALPHA = 9,
VK_BLEND_CONSTANT_COLOR = 10,
VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
VK_BLEND_CONSTANT_ALPHA = 12,
VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13,
VK_BLEND_SRC_ALPHA_SATURATE = 14,
VK_BLEND_SRC1_COLOR = 15,
VK_BLEND_ONE_MINUS_SRC1_COLOR = 16,
VK_BLEND_SRC1_ALPHA = 17,
VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18,
VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
VK_BLEND_MAX_ENUM = 0x7FFFFFFF
} VkBlend;
typedef enum {
VK_BLEND_OP_ADD = 0,
VK_BLEND_OP_SUBTRACT = 1,
VK_BLEND_OP_REVERSE_SUBTRACT = 2,
VK_BLEND_OP_MIN = 3,
VK_BLEND_OP_MAX = 4,
VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
} VkBlendOp;
typedef enum {
VK_TEX_FILTER_NEAREST = 0,
VK_TEX_FILTER_LINEAR = 1,
VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST,
VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR,
VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1),
VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF
} VkTexFilter;
typedef enum {
VK_TEX_MIPMAP_MODE_BASE = 0,
VK_TEX_MIPMAP_MODE_NEAREST = 1,
VK_TEX_MIPMAP_MODE_LINEAR = 2,
VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE,
VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR,
VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1),
VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
} VkTexMipmapMode;
typedef enum {
VK_TEX_ADDRESS_WRAP = 0,
VK_TEX_ADDRESS_MIRROR = 1,
VK_TEX_ADDRESS_CLAMP = 2,
VK_TEX_ADDRESS_MIRROR_ONCE = 3,
VK_TEX_ADDRESS_CLAMP_BORDER = 4,
VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP,
VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER,
VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1),
VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF
} VkTexAddress;
typedef enum {
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;
typedef enum {
VK_DESCRIPTOR_TYPE_SAMPLER = 0,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
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_INPUT_ATTACHMENT,
VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorType;
typedef enum {
VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0,
VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1,
VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1),
VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorPoolUsage;
typedef enum {
VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC,
VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1),
VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorSetUsage;
typedef enum {
VK_IMAGE_LAYOUT_UNDEFINED = 0,
VK_IMAGE_LAYOUT_GENERAL = 1,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1),
VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
} VkImageLayout;
typedef enum {
VK_ATTACHMENT_LOAD_OP_LOAD = 0,
VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentLoadOp;
typedef enum {
VK_ATTACHMENT_STORE_OP_STORE = 0,
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),
VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentStoreOp;
typedef enum {
VK_PIPELINE_BIND_POINT_COMPUTE = 0,
VK_PIPELINE_BIND_POINT_GRAPHICS = 1,
VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1),
VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
} VkPipelineBindPoint;
typedef enum {
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_UINT32 = 1,
VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkIndexType;
typedef enum {
VK_TIMESTAMP_TYPE_TOP = 0,
VK_TIMESTAMP_TYPE_BOTTOM = 1,
VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP,
VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM,
VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 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,
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400,
} 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,
VK_QUEUE_DMA_BIT = 0x00000004,
VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
VK_QUEUE_EXTENDED_BIT = 0x40000000,
} VkQueueFlagBits;
typedef VkFlags VkQueueFlags;
typedef enum {
VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001,
VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002,
VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004,
VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008,
} VkMemoryPropertyFlagBits;
typedef VkFlags VkMemoryPropertyFlags;
typedef enum {
VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001,
} VkMemoryHeapFlagBits;
typedef VkFlags VkMemoryHeapFlags;
typedef enum {
VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
} VkDeviceCreateFlagBits;
typedef VkFlags VkDeviceCreateFlags;
typedef VkFlags VkMemoryMapFlags;
typedef enum {
VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
} VkFenceCreateFlagBits;
typedef VkFlags VkFenceCreateFlags;
typedef VkFlags VkSemaphoreCreateFlags;
typedef VkFlags VkEventCreateFlags;
typedef enum {
VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001,
VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002,
VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004,
VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008,
VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010,
VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020,
VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040,
VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080,
VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100,
VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200,
VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400,
} VkQueryPipelineStatisticFlagBits;
typedef VkFlags VkQueryPipelineStatisticFlags;
typedef enum {
VK_QUERY_RESULT_DEFAULT = 0,
VK_QUERY_RESULT_64_BIT = 0x00000001,
VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
} VkQueryResultFlagBits;
typedef VkFlags VkQueryResultFlags;
typedef enum {
VK_BUFFER_USAGE_GENERAL = 0,
VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
typedef enum {
VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001,
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
typedef enum {
VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
VK_IMAGE_CREATE_SPARSE_BIT = 0x00000002,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000004,
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000008,
} VkImageCreateFlagBits;
typedef VkFlags VkImageCreateFlags;
typedef enum {
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 {
VK_CHANNEL_R_BIT = 0x00000001,
VK_CHANNEL_G_BIT = 0x00000002,
VK_CHANNEL_B_BIT = 0x00000004,
VK_CHANNEL_A_BIT = 0x00000008,
} VkChannelFlagBits;
typedef VkFlags VkChannelFlags;
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;
typedef enum {
VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002,
VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004,
VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
} VkShaderStageFlagBits;
typedef VkFlags VkShaderStageFlags;
typedef enum {
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_OUTPUT_SHADER_WRITE_BIT = 0x00000002,
VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004,
VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008,
VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010,
} VkMemoryOutputFlagBits;
typedef VkFlags VkMemoryOutputFlags;
typedef enum {
VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001,
VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002,
VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004,
VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008,
VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010,
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_INPUT_ATTACHMENT_BIT = 0x00000100,
VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200,
} VkMemoryInputFlagBits;
typedef VkFlags VkMemoryInputFlags;
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,
VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010,
} 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_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
} VkQueryControlFlagBits;
typedef VkFlags VkQueryControlFlags;
typedef struct {
VkStructureType sType;
const void* pNext;
const char* pAppName;
uint32_t appVersion;
const char* pEngineName;
uint32_t engineVersion;
uint32_t apiVersion;
} VkApplicationInfo;
typedef void* (VKAPI *PFN_vkAllocFunction)(
void* pUserData,
size_t size,
size_t alignment,
VkSystemAllocType allocType);
typedef void (VKAPI *PFN_vkFreeFunction)(
void* pUserData,
void* pMem);
typedef struct {
void* pUserData;
PFN_vkAllocFunction pfnAlloc;
PFN_vkFreeFunction pfnFree;
} VkAllocCallbacks;
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 {
uint64_t maxResourceSize;
uint32_t maxSamples;
} VkImageFormatProperties;
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 vendorId;
uint32_t deviceId;
VkPhysicalDeviceType deviceType;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
uint8_t pipelineCacheUUID[VK_UUID_LENGTH];
} VkPhysicalDeviceProperties;
typedef struct {
VkQueueFlags queueFlags;
uint32_t queueCount;
VkBool32 supportsTimestamps;
} VkPhysicalDeviceQueueProperties;
typedef struct {
VkMemoryPropertyFlags propertyFlags;
uint32_t heapIndex;
} VkMemoryType;
typedef struct {
VkDeviceSize size;
VkMemoryHeapFlags flags;
} VkMemoryHeap;
typedef struct {
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);
typedef struct {
uint32_t queueNodeIndex;
uint32_t queueCount;
} VkDeviceQueueCreateInfo;
typedef struct {
VkStructureType sType;
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 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;
uint32_t memoryTypeIndex;
} VkMemoryAllocInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkDeviceMemory mem;
VkDeviceSize offset;
VkDeviceSize size;
} VkMappedMemoryRange;
typedef struct {
VkDeviceSize size;
VkDeviceSize alignment;
VkDeviceSize granularity;
uint32_t memoryTypeBits;
} VkMemoryRequirements;
typedef struct {
VkImageAspect aspect;
uint32_t mipLevel;
uint32_t arraySlice;
} VkImageSubresource;
typedef struct {
int32_t x;
int32_t y;
int32_t z;
} VkOffset3D;
typedef struct {
int32_t width;
int32_t height;
int32_t depth;
} VkExtent3D;
typedef struct {
VkImageSubresource subresource;
VkOffset3D offset;
VkExtent3D extent;
} VkImageMemoryBindInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkFenceCreateFlags flags;
} VkFenceCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkSemaphoreCreateFlags flags;
} VkSemaphoreCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkEventCreateFlags flags;
} VkEventCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkQueryType queryType;
uint32_t slots;
VkQueryPipelineStatisticFlags pipelineStatistics;
} VkQueryPoolCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkDeviceSize size;
VkBufferUsageFlags usage;
VkBufferCreateFlags flags;
} VkBufferCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkBuffer buffer;
VkBufferViewType viewType;
VkFormat format;
VkDeviceSize offset;
VkDeviceSize range;
} VkBufferViewCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkImageType imageType;
VkFormat format;
VkExtent3D extent;
uint32_t mipLevels;
uint32_t arraySize;
uint32_t samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkImageCreateFlags flags;
} VkImageCreateInfo;
typedef struct {
VkDeviceSize offset;
VkDeviceSize size;
VkDeviceSize rowPitch;
VkDeviceSize depthPitch;
} VkSubresourceLayout;
typedef struct {
VkChannelSwizzle r;
VkChannelSwizzle g;
VkChannelSwizzle b;
VkChannelSwizzle a;
} VkChannelMapping;
typedef struct {
VkImageAspect aspect;
uint32_t baseMipLevel;
uint32_t mipLevels;
uint32_t baseArraySlice;
uint32_t arraySize;
} VkImageSubresourceRange;
typedef struct {
VkStructureType sType;
const void* pNext;
VkImage image;
VkImageViewType viewType;
VkFormat format;
VkChannelMapping channels;
VkImageSubresourceRange subresourceRange;
} VkImageViewCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkImage image;
VkFormat format;
uint32_t mipLevel;
uint32_t baseArraySlice;
uint32_t arraySize;
VkAttachmentViewCreateFlags flags;
} VkAttachmentViewCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
size_t codeSize;
const void* pCode;
VkShaderModuleCreateFlags flags;
} VkShaderModuleCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
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 mapEntryCount;
const VkSpecializationMapEntry* pMap;
const void* pData;
} VkSpecializationInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkShaderStage stage;
VkShader shader;
const VkSpecializationInfo* pSpecializationInfo;
} VkPipelineShaderStageCreateInfo;
typedef struct {
uint32_t binding;
uint32_t strideInBytes;
VkVertexInputStepRate stepRate;
} VkVertexInputBindingDescription;
typedef struct {
uint32_t location;
uint32_t binding;
VkFormat format;
uint32_t offsetInBytes;
} VkVertexInputAttributeDescription;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t bindingCount;
const VkVertexInputBindingDescription* pVertexBindingDescriptions;
uint32_t attributeCount;
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
} VkPipelineVertexInputStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkPrimitiveTopology topology;
VkBool32 primitiveRestartEnable;
} VkPipelineInputAssemblyStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t patchControlPoints;
} VkPipelineTessellationStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t viewportCount;
} VkPipelineViewportStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkBool32 depthClipEnable;
VkBool32 rasterizerDiscardEnable;
VkFillMode fillMode;
VkCullMode cullMode;
VkFrontFace frontFace;
} VkPipelineRasterStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t rasterSamples;
VkBool32 sampleShadingEnable;
float minSampleShading;
VkSampleMask sampleMask;
} VkPipelineMultisampleStateCreateInfo;
typedef struct {
VkStencilOp stencilFailOp;
VkStencilOp stencilPassOp;
VkStencilOp stencilDepthFailOp;
VkCompareOp stencilCompareOp;
} VkStencilOpState;
typedef struct {
VkStructureType sType;
const void* pNext;
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
VkBool32 depthBoundsEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
} VkPipelineDepthStencilStateCreateInfo;
typedef struct {
VkBool32 blendEnable;
VkBlend srcBlendColor;
VkBlend destBlendColor;
VkBlendOp blendOpColor;
VkBlend srcBlendAlpha;
VkBlend destBlendAlpha;
VkBlendOp blendOpAlpha;
VkChannelFlags channelWriteMask;
} VkPipelineColorBlendAttachmentState;
typedef struct {
VkStructureType sType;
const void* pNext;
VkBool32 alphaToCoverageEnable;
VkBool32 logicOpEnable;
VkLogicOp logicOp;
uint32_t attachmentCount;
const VkPipelineColorBlendAttachmentState* pAttachments;
} VkPipelineColorBlendStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t stageCount;
const VkPipelineShaderStageCreateInfo* pStages;
const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
const VkPipelineTessellationStateCreateInfo* pTessellationState;
const VkPipelineViewportStateCreateInfo* pViewportState;
const VkPipelineRasterStateCreateInfo* pRasterState;
const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
VkPipelineCreateFlags flags;
VkPipelineLayout layout;
VkRenderPass renderPass;
uint32_t subpass;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
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 {
VkStructureType sType;
const void* pNext;
VkTexFilter magFilter;
VkTexFilter minFilter;
VkTexMipmapMode mipMode;
VkTexAddress addressU;
VkTexAddress addressV;
VkTexAddress addressW;
float mipLodBias;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
} VkSamplerCreateInfo;
typedef struct {
VkDescriptorType descriptorType;
uint32_t arraySize;
VkShaderStageFlags stageFlags;
const VkSampler* pImmutableSamplers;
} VkDescriptorSetLayoutBinding;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t count;
const VkDescriptorSetLayoutBinding* pBinding;
} VkDescriptorSetLayoutCreateInfo;
typedef struct {
VkDescriptorType type;
uint32_t count;
} VkDescriptorTypeCount;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t count;
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;
float width;
float height;
float minDepth;
float maxDepth;
} VkViewport;
typedef struct {
int32_t x;
int32_t y;
} VkOffset2D;
typedef struct {
int32_t width;
int32_t height;
} VkExtent2D;
typedef struct {
VkOffset2D offset;
VkExtent2D extent;
} VkRect2D;
typedef struct {
VkStructureType sType;
const void* pNext;
uint32_t viewportAndScissorCount;
const VkViewport* pViewports;
const VkRect2D* pScissors;
} VkDynamicViewportStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
float depthBias;
float depthBiasClamp;
float slopeScaledDepthBias;
float lineWidth;
} VkDynamicRasterStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
float blendConst[4];
} VkDynamicColorBlendStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
float minDepthBounds;
float maxDepthBounds;
uint32_t stencilReadMask;
uint32_t stencilWriteMask;
uint32_t stencilFrontRef;
uint32_t stencilBackRef;
} VkDynamicDepthStencilStateCreateInfo;
typedef struct {
VkAttachmentView view;
VkImageLayout layout;
} VkAttachmentBindInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
uint32_t attachmentCount;
const VkAttachmentBindInfo* pAttachments;
uint32_t width;
uint32_t height;
uint32_t layers;
} VkFramebufferCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkFormat format;
uint32_t samples;
VkAttachmentLoadOp loadOp;
VkAttachmentStoreOp storeOp;
VkAttachmentLoadOp stencilLoadOp;
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 destSubpass;
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;
typedef struct {
VkStructureType sType;
const void* pNext;
VkCmdBufferOptimizeFlags flags;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
} VkCmdBufferBeginInfo;
typedef struct {
VkDeviceSize srcOffset;
VkDeviceSize destOffset;
VkDeviceSize copySize;
} VkBufferCopy;
typedef struct {
VkImageSubresource srcSubresource;
VkOffset3D srcOffset;
VkImageSubresource destSubresource;
VkOffset3D destOffset;
VkExtent3D extent;
} VkImageCopy;
typedef struct {
VkImageSubresource srcSubresource;
VkOffset3D srcOffset;
VkExtent3D srcExtent;
VkImageSubresource destSubresource;
VkOffset3D destOffset;
VkExtent3D destExtent;
} VkImageBlit;
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;
} VkRect3D;
typedef struct {
VkImageSubresource srcSubresource;
VkOffset3D srcOffset;
VkImageSubresource destSubresource;
VkOffset3D destOffset;
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;
VkRect2D renderArea;
uint32_t attachmentCount;
const VkClearValue* pAttachmentClearValues;
} VkRenderPassBeginInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkMemoryOutputFlags outputMask;
VkMemoryInputFlags inputMask;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
} VkBufferMemoryBarrier;
typedef struct {
uint32_t x;
uint32_t y;
uint32_t z;
} VkDispatchIndirectCmd;
typedef struct {
uint32_t indexCount;
uint32_t instanceCount;
uint32_t firstIndex;
int32_t vertexOffset;
uint32_t firstInstance;
} VkDrawIndexedIndirectCmd;
typedef struct {
uint32_t vertexCount;
uint32_t instanceCount;
uint32_t firstVertex;
uint32_t firstInstance;
} VkDrawIndirectCmd;
typedef struct {
VkStructureType sType;
const void* pNext;
VkMemoryOutputFlags outputMask;
VkMemoryInputFlags inputMask;
VkImageLayout oldLayout;
VkImageLayout newLayout;
VkImage image;
VkImageSubresourceRange subresourceRange;
} VkImageMemoryBarrier;
typedef struct {
VkStructureType sType;
const void* pNext;
VkMemoryOutputFlags outputMask;
VkMemoryInputFlags inputMask;
} VkMemoryBarrier;
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_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties);
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_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_vkDeviceWaitIdle)(VkDevice device);
typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
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_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, 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_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_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 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_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_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, 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, 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, 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_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
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, 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 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);
#ifdef VK_PROTOTYPES
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
VkInstance* pInstance);
VkResult VKAPI vkDestroyInstance(
VkInstance instance);
VkResult VKAPI vkEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
VkResult VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures);
VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties);
VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageFormatProperties* pImageFormatProperties);
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);
PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
VkDevice device,
const char* pName);
VkResult VKAPI vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
VkDevice* pDevice);
VkResult VKAPI vkDestroyDevice(
VkDevice device);
VkResult VKAPI vkGetGlobalExtensionProperties(
const char* pLayerName,
uint32_t* pCount,
VkExtensionProperties* pProperties);
VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pCount,
VkExtensionProperties* pProperties);
VkResult VKAPI vkGetGlobalLayerProperties(
uint32_t* pCount,
VkLayerProperties* pProperties);
VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkLayerProperties* pProperties);
VkResult VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
VkQueue* pQueue);
VkResult VKAPI vkQueueSubmit(
VkQueue queue,
uint32_t cmdBufferCount,
const VkCmdBuffer* pCmdBuffers,
VkFence fence);
VkResult VKAPI vkQueueWaitIdle(
VkQueue queue);
VkResult VKAPI vkDeviceWaitIdle(
VkDevice device);
VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
VkDeviceMemory* pMem);
VkResult VKAPI vkFreeMemory(
VkDevice device,
VkDeviceMemory mem);
VkResult VKAPI vkMapMemory(
VkDevice device,
VkDeviceMemory mem,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData);
VkResult VKAPI vkUnmapMemory(
VkDevice device,
VkDeviceMemory mem);
VkResult VKAPI vkFlushMappedMemoryRanges(
VkDevice device,
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges);
VkResult VKAPI vkInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges);
VkResult VKAPI vkDestroyObject(
VkDevice device,
VkObjectType objType,
VkObject object);
VkResult VKAPI vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory mem,
VkDeviceSize memOffset);
VkResult VKAPI vkBindImageMemory(
VkDevice device,
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(
VkQueue queue,
VkBuffer buffer,
VkDeviceSize rangeOffset,
VkDeviceSize rangeSize,
VkDeviceMemory mem,
VkDeviceSize memOffset);
VkResult VKAPI vkQueueBindSparseImageMemory(
VkQueue queue,
VkImage image,
const VkImageMemoryBindInfo* pBindInfo,
VkDeviceMemory mem,
VkDeviceSize memOffset);
VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
VkFence* pFence);
VkResult VKAPI vkDestroyFence(
VkDevice device,
VkFence fence);
VkResult VKAPI vkResetFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences);
VkResult VKAPI vkGetFenceStatus(
VkDevice device,
VkFence fence);
VkResult VKAPI vkWaitForFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
uint64_t timeout);
VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
VkSemaphore* pSemaphore);
VkResult VKAPI vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore);
VkResult VKAPI vkQueueSignalSemaphore(
VkQueue queue,
VkSemaphore semaphore);
VkResult VKAPI vkQueueWaitSemaphore(
VkQueue queue,
VkSemaphore semaphore);
VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
VkEvent* pEvent);
VkResult VKAPI vkDestroyEvent(
VkDevice device,
VkEvent event);
VkResult VKAPI vkGetEventStatus(
VkDevice device,
VkEvent event);
VkResult VKAPI vkSetEvent(
VkDevice device,
VkEvent event);
VkResult VKAPI vkResetEvent(
VkDevice device,
VkEvent event);
VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
VkQueryPool* pQueryPool);
VkResult VKAPI vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool);
VkResult VKAPI vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
size_t* pDataSize,
void* pData,
VkQueryResultFlags flags);
VkResult VKAPI vkCreateBuffer(
VkDevice device,
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 VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout);
VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
VkImageView* pView);
VkResult VKAPI vkDestroyImageView(
VkDevice device,
VkImageView imageView);
VkResult VKAPI vkCreateAttachmentView(
VkDevice device,
const VkAttachmentViewCreateInfo* pCreateInfo,
VkAttachmentView* pView);
VkResult VKAPI vkDestroyAttachmentView(
VkDevice device,
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 vkDestroyShader(
VkDevice device,
VkShader shader);
VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
VkPipelineCache* pPipelineCache);
VkResult VKAPI vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache);
size_t VKAPI vkGetPipelineCacheSize(
VkDevice device,
VkPipelineCache pipelineCache);
VkResult VKAPI vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
void* pData);
VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
VkPipelineCache destCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches);
VkResult VKAPI vkCreateGraphicsPipelines(
VkDevice device,
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,
uint32_t maxSets,
const VkDescriptorPoolCreateInfo* pCreateInfo,
VkDescriptorPool* pDescriptorPool);
VkResult VKAPI vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool);
VkResult VKAPI vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool);
VkResult VKAPI vkAllocDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorSetUsage setUsage,
uint32_t count,
const VkDescriptorSetLayout* pSetLayouts,
VkDescriptorSet* pDescriptorSets,
uint32_t* pCount);
VkResult VKAPI vkUpdateDescriptorSets(
VkDevice device,
uint32_t writeCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t copyCount,
const VkCopyDescriptorSet* pDescriptorCopies);
VkResult VKAPI vkCreateDynamicViewportState(
VkDevice device,
const VkDynamicViewportStateCreateInfo* pCreateInfo,
VkDynamicViewportState* pState);
VkResult VKAPI vkDestroyDynamicViewportState(
VkDevice device,
VkDynamicViewportState dynamicViewportState);
VkResult VKAPI vkCreateDynamicRasterState(
VkDevice device,
const VkDynamicRasterStateCreateInfo* pCreateInfo,
VkDynamicRasterState* pState);
VkResult VKAPI vkDestroyDynamicRasterState(
VkDevice device,
VkDynamicRasterState dynamicRasterState);
VkResult VKAPI vkCreateDynamicColorBlendState(
VkDevice device,
const VkDynamicColorBlendStateCreateInfo* pCreateInfo,
VkDynamicColorBlendState* pState);
VkResult VKAPI vkDestroyDynamicColorBlendState(
VkDevice device,
VkDynamicColorBlendState dynamicColorBlendState);
VkResult VKAPI vkCreateDynamicDepthStencilState(
VkDevice device,
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,
VkExtent2D* pGranularity);
VkResult VKAPI vkCreateCommandBuffer(
VkDevice device,
const VkCmdBufferCreateInfo* pCreateInfo,
VkCmdBuffer* pCmdBuffer);
VkResult VKAPI vkDestroyCommandBuffer(
VkDevice device,
VkCmdBuffer commandBuffer);
VkResult VKAPI vkBeginCommandBuffer(
VkCmdBuffer cmdBuffer,
const VkCmdBufferBeginInfo* pBeginInfo);
VkResult VKAPI vkEndCommandBuffer(
VkCmdBuffer cmdBuffer);
VkResult VKAPI vkResetCommandBuffer(
VkCmdBuffer cmdBuffer);
void VKAPI vkCmdBindPipeline(
VkCmdBuffer cmdBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline);
void VKAPI vkCmdBindDynamicViewportState(
VkCmdBuffer cmdBuffer,
VkDynamicViewportState dynamicViewportState);
void VKAPI vkCmdBindDynamicRasterState(
VkCmdBuffer cmdBuffer,
VkDynamicRasterState dynamicRasterState);
void VKAPI vkCmdBindDynamicColorBlendState(
VkCmdBuffer cmdBuffer,
VkDynamicColorBlendState dynamicColorBlendState);
void VKAPI vkCmdBindDynamicDepthStencilState(
VkCmdBuffer cmdBuffer,
VkDynamicDepthStencilState dynamicDepthStencilState);
void VKAPI vkCmdBindDescriptorSets(
VkCmdBuffer cmdBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t setCount,
const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets);
void VKAPI vkCmdBindIndexBuffer(
VkCmdBuffer cmdBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType);
void VKAPI vkCmdBindVertexBuffers(
VkCmdBuffer cmdBuffer,
uint32_t startBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets);
void VKAPI vkCmdDraw(
VkCmdBuffer cmdBuffer,
uint32_t firstVertex,
uint32_t vertexCount,
uint32_t firstInstance,
uint32_t instanceCount);
void VKAPI vkCmdDrawIndexed(
VkCmdBuffer cmdBuffer,
uint32_t firstIndex,
uint32_t indexCount,
int32_t vertexOffset,
uint32_t firstInstance,
uint32_t instanceCount);
void VKAPI vkCmdDrawIndirect(
VkCmdBuffer cmdBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride);
void VKAPI vkCmdDrawIndexedIndirect(
VkCmdBuffer cmdBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride);
void VKAPI vkCmdDispatch(
VkCmdBuffer cmdBuffer,
uint32_t x,
uint32_t y,
uint32_t z);
void VKAPI vkCmdDispatchIndirect(
VkCmdBuffer cmdBuffer,
VkBuffer buffer,
VkDeviceSize offset);
void VKAPI vkCmdCopyBuffer(
VkCmdBuffer cmdBuffer,
VkBuffer srcBuffer,
VkBuffer destBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions);
void VKAPI vkCmdCopyImage(
VkCmdBuffer cmdBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage destImage,
VkImageLayout destImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions);
void VKAPI vkCmdBlitImage(
VkCmdBuffer cmdBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage destImage,
VkImageLayout destImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkTexFilter filter);
void VKAPI vkCmdCopyBufferToImage(
VkCmdBuffer cmdBuffer,
VkBuffer srcBuffer,
VkImage destImage,
VkImageLayout destImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions);
void VKAPI vkCmdCopyImageToBuffer(
VkCmdBuffer cmdBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer destBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions);
void VKAPI vkCmdUpdateBuffer(
VkCmdBuffer cmdBuffer,
VkBuffer destBuffer,
VkDeviceSize destOffset,
VkDeviceSize dataSize,
const uint32_t* pData);
void VKAPI vkCmdFillBuffer(
VkCmdBuffer cmdBuffer,
VkBuffer destBuffer,
VkDeviceSize destOffset,
VkDeviceSize fillSize,
uint32_t data);
void VKAPI vkCmdClearColorImage(
VkCmdBuffer cmdBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges);
void VKAPI vkCmdClearDepthStencilImage(
VkCmdBuffer cmdBuffer,
VkImage image,
VkImageLayout imageLayout,
float depth,
uint32_t stencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges);
void VKAPI vkCmdClearColorAttachment(
VkCmdBuffer cmdBuffer,
uint32_t colorAttachment,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rectCount,
const VkRect3D* pRects);
void VKAPI vkCmdClearDepthStencilAttachment(
VkCmdBuffer cmdBuffer,
VkImageAspectFlags imageAspectMask,
VkImageLayout imageLayout,
float depth,
uint32_t stencil,
uint32_t rectCount,
const VkRect3D* pRects);
void VKAPI vkCmdResolveImage(
VkCmdBuffer cmdBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage destImage,
VkImageLayout destImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions);
void VKAPI vkCmdSetEvent(
VkCmdBuffer cmdBuffer,
VkEvent event,
VkPipelineStageFlags stageMask);
void VKAPI vkCmdResetEvent(
VkCmdBuffer cmdBuffer,
VkEvent event,
VkPipelineStageFlags stageMask);
void VKAPI vkCmdWaitEvents(
VkCmdBuffer cmdBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags destStageMask,
uint32_t memBarrierCount,
const void* const* ppMemBarriers);
void VKAPI vkCmdPipelineBarrier(
VkCmdBuffer cmdBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags destStageMask,
VkBool32 byRegion,
uint32_t memBarrierCount,
const void* const* ppMemBarriers);
void VKAPI vkCmdBeginQuery(
VkCmdBuffer cmdBuffer,
VkQueryPool queryPool,
uint32_t slot,
VkQueryControlFlags flags);
void VKAPI vkCmdEndQuery(
VkCmdBuffer cmdBuffer,
VkQueryPool queryPool,
uint32_t slot);
void VKAPI vkCmdResetQueryPool(
VkCmdBuffer cmdBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount);
void VKAPI vkCmdWriteTimestamp(
VkCmdBuffer cmdBuffer,
VkTimestampType timestampType,
VkBuffer destBuffer,
VkDeviceSize destOffset);
void VKAPI vkCmdCopyQueryPoolResults(
VkCmdBuffer cmdBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
VkBuffer destBuffer,
VkDeviceSize destOffset,
VkDeviceSize destStride,
VkQueryResultFlags flags);
void VKAPI vkCmdPushConstants(
VkCmdBuffer cmdBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t start,
uint32_t length,
const void* values);
void VKAPI vkCmdBeginRenderPass(
VkCmdBuffer cmdBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkRenderPassContents contents);
void VKAPI vkCmdNextSubpass(
VkCmdBuffer cmdBuffer,
VkRenderPassContents contents);
void VKAPI vkCmdEndRenderPass(
VkCmdBuffer cmdBuffer);
void VKAPI vkCmdExecuteCommands(
VkCmdBuffer cmdBuffer,
uint32_t cmdBuffersCount,
const VkCmdBuffer* pCmdBuffers);
#endif
#ifdef __cplusplus
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink