| #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. |
| ** |
| */ |
| |
| |
| #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, 197, 0) |
| |
| |
| #define VK_NULL_HANDLE 0 |
| |
| |
| |
| #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; |
| |
| |
| #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) |
| #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; |
| #else |
| #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; |
| #endif |
| |
| |
| |
| typedef uint32_t VkFlags; |
| typedef uint32_t VkBool32; |
| typedef uint64_t VkDeviceSize; |
| typedef uint32_t VkSampleMask; |
| |
| VK_DEFINE_HANDLE(VkInstance) |
| VK_DEFINE_HANDLE(VkPhysicalDevice) |
| VK_DEFINE_HANDLE(VkDevice) |
| VK_DEFINE_HANDLE(VkQueue) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) |
| VK_DEFINE_HANDLE(VkCommandBuffer) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) |
| |
| #define VK_LOD_CLAMP_NONE 1000.0f |
| #define VK_REMAINING_MIP_LEVELS (~0U) |
| #define VK_REMAINING_ARRAY_LAYERS (~0U) |
| #define VK_WHOLE_SIZE (~0ULL) |
| #define VK_ATTACHMENT_UNUSED (~0U) |
| #define VK_TRUE 1 |
| #define VK_FALSE 0 |
| #define VK_QUEUE_FAMILY_IGNORED (~0U) |
| #define VK_SUBPASS_EXTERNAL (~0U) |
| #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 |
| |
| |
| typedef enum { |
| VK_SUCCESS = 0, |
| VK_NOT_READY = 1, |
| VK_TIMEOUT = 2, |
| VK_EVENT_SET = 3, |
| VK_EVENT_RESET = 4, |
| VK_INCOMPLETE = 5, |
| VK_ERROR_OUT_OF_HOST_MEMORY = -1, |
| VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, |
| VK_ERROR_INITIALIZATION_FAILED = -3, |
| VK_ERROR_DEVICE_LOST = -4, |
| VK_ERROR_MEMORY_MAP_FAILED = -5, |
| VK_ERROR_LAYER_NOT_PRESENT = -6, |
| VK_ERROR_EXTENSION_NOT_PRESENT = -7, |
| VK_ERROR_FEATURE_NOT_PRESENT = -8, |
| VK_ERROR_INCOMPATIBLE_DRIVER = -9, |
| VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER, |
| VK_RESULT_END_RANGE = VK_INCOMPLETE, |
| VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1), |
| VK_RESULT_MAX_ENUM = 0x7FFFFFFF |
| } VkResult; |
| |
| typedef enum { |
| VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, |
| VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, |
| VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, |
| VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, |
| VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, |
| VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 5, |
| VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, |
| VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, |
| VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, |
| VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, |
| VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, |
| VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, |
| VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, |
| VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, |
| VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, |
| VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, |
| VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 17, |
| VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 18, |
| VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, |
| VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 20, |
| VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21, |
| VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22, |
| VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23, |
| VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24, |
| VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25, |
| VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26, |
| VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, |
| VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 28, |
| VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 29, |
| VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 30, |
| VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 31, |
| VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 32, |
| VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 33, |
| VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 34, |
| VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 35, |
| VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 36, |
| VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37, |
| VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38, |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39, |
| VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40, |
| VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41, |
| VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, |
| VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, |
| VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, |
| VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, |
| VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, |
| VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 47, |
| VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48, |
| VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, |
| VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO, |
| VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), |
| VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkStructureType; |
| |
| typedef enum { |
| VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0, |
| VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, |
| VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, |
| VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, |
| VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, |
| VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION, |
| VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, |
| VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1), |
| VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF |
| } VkSystemAllocationScope; |
| |
| typedef enum { |
| VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, |
| VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, |
| VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, |
| VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), |
| VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkInternalAllocationType; |
| |
| 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_X8 = 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_RANGE_SIZE = (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_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), |
| VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkImageType; |
| |
| typedef enum { |
| VK_IMAGE_TILING_OPTIMAL = 0, |
| VK_IMAGE_TILING_LINEAR = 1, |
| VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, |
| VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, |
| VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 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_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), |
| VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkPhysicalDeviceType; |
| |
| typedef enum { |
| VK_QUERY_TYPE_OCCLUSION = 0, |
| VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, |
| VK_QUERY_TYPE_TIMESTAMP = 2, |
| VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, |
| VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, |
| VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), |
| VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkQueryType; |
| |
| typedef enum { |
| VK_SHARING_MODE_EXCLUSIVE = 0, |
| VK_SHARING_MODE_CONCURRENT = 1, |
| VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, |
| VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, |
| VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), |
| VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF |
| } VkSharingMode; |
| |
| 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_SRC_OPTIMAL = 6, |
| VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, |
| VK_IMAGE_LAYOUT_PREINITIALIZED = 8, |
| VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, |
| VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, |
| VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), |
| VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF |
| } VkImageLayout; |
| |
| 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_RANGE_SIZE = (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_IDENTITY = 0, |
| VK_CHANNEL_SWIZZLE_ZERO = 1, |
| VK_CHANNEL_SWIZZLE_ONE = 2, |
| VK_CHANNEL_SWIZZLE_R = 3, |
| VK_CHANNEL_SWIZZLE_G = 4, |
| VK_CHANNEL_SWIZZLE_B = 5, |
| VK_CHANNEL_SWIZZLE_A = 6, |
| VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_IDENTITY, |
| VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, |
| VK_CHANNEL_SWIZZLE_RANGE_SIZE = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1), |
| VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF |
| } VkChannelSwizzle; |
| |
| 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_RANGE_SIZE = (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_WITH_ADJACENCY = 6, |
| VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 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_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), |
| VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF |
| } VkPrimitiveTopology; |
| |
| typedef enum { |
| VK_FILL_MODE_SOLID = 0, |
| VK_FILL_MODE_WIREFRAME = 1, |
| VK_FILL_MODE_POINTS = 2, |
| VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_SOLID, |
| VK_FILL_MODE_END_RANGE = VK_FILL_MODE_POINTS, |
| VK_FILL_MODE_RANGE_SIZE = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1), |
| VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF |
| } VkFillMode; |
| |
| typedef enum { |
| VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, |
| VK_FRONT_FACE_CLOCKWISE = 1, |
| VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, |
| VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, |
| VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 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_OR_EQUAL = 3, |
| VK_COMPARE_OP_GREATER = 4, |
| VK_COMPARE_OP_NOT_EQUAL = 5, |
| VK_COMPARE_OP_GREATER_OR_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_RANGE_SIZE = (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_INCREMENT_AND_CLAMP = 3, |
| VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, |
| VK_STENCIL_OP_INVERT = 5, |
| VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, |
| VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, |
| VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, |
| VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, |
| VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_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_NO_OP = 5, |
| VK_LOGIC_OP_XOR = 6, |
| VK_LOGIC_OP_OR = 7, |
| VK_LOGIC_OP_NOR = 8, |
| VK_LOGIC_OP_EQUIVALENT = 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_RANGE_SIZE = (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_DST_COLOR = 4, |
| VK_BLEND_ONE_MINUS_DST_COLOR = 5, |
| VK_BLEND_SRC_ALPHA = 6, |
| VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, |
| VK_BLEND_DST_ALPHA = 8, |
| VK_BLEND_ONE_MINUS_DST_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_RANGE_SIZE = (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_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), |
| VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF |
| } VkBlendOp; |
| |
| typedef enum { |
| VK_DYNAMIC_STATE_VIEWPORT = 0, |
| VK_DYNAMIC_STATE_SCISSOR = 1, |
| VK_DYNAMIC_STATE_LINE_WIDTH = 2, |
| VK_DYNAMIC_STATE_DEPTH_BIAS = 3, |
| VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, |
| VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, |
| VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, |
| VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, |
| VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, |
| VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, |
| VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, |
| VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), |
| VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF |
| } VkDynamicState; |
| |
| typedef enum { |
| VK_FILTER_NEAREST = 0, |
| VK_FILTER_LINEAR = 1, |
| VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, |
| VK_FILTER_END_RANGE = VK_FILTER_LINEAR, |
| VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), |
| VK_FILTER_MAX_ENUM = 0x7FFFFFFF |
| } VkFilter; |
| |
| typedef enum { |
| VK_SAMPLER_MIPMAP_MODE_BASE = 0, |
| VK_SAMPLER_MIPMAP_MODE_NEAREST = 1, |
| VK_SAMPLER_MIPMAP_MODE_LINEAR = 2, |
| VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_BASE, |
| VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, |
| VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1), |
| VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF |
| } VkSamplerMipmapMode; |
| |
| typedef enum { |
| VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, |
| VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, |
| VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, |
| VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, |
| VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, |
| VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, |
| VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, |
| VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), |
| VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF |
| } VkSamplerAddressMode; |
| |
| 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_RANGE_SIZE = (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_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), |
| VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkDescriptorType; |
| |
| 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_RANGE_SIZE = (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_RANGE_SIZE = (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_GRAPHICS = 0, |
| VK_PIPELINE_BIND_POINT_COMPUTE = 1, |
| VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, |
| VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, |
| VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), |
| VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF |
| } VkPipelineBindPoint; |
| |
| typedef enum { |
| VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, |
| VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, |
| VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, |
| VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, |
| VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), |
| VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF |
| } VkCommandBufferLevel; |
| |
| 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_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), |
| VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF |
| } VkIndexType; |
| |
| typedef enum { |
| VK_RENDER_PASS_CONTENTS_INLINE = 0, |
| VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, |
| VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, |
| VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, |
| VK_RENDER_PASS_CONTENTS_RANGE_SIZE = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), |
| VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF |
| } VkRenderPassContents; |
| |
| typedef VkFlags VkInstanceCreateFlags; |
| |
| 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_BLIT_SRC_BIT = 0x00000400, |
| VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, |
| } VkFormatFeatureFlagBits; |
| typedef VkFlags VkFormatFeatureFlags; |
| |
| typedef enum { |
| VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, |
| VK_IMAGE_USAGE_TRANSFER_DST_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_ATTACHMENT_BIT = 0x00000020, |
| VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, |
| VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, |
| } VkImageUsageFlagBits; |
| typedef VkFlags VkImageUsageFlags; |
| |
| typedef enum { |
| VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, |
| VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, |
| VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, |
| VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, |
| VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, |
| } VkImageCreateFlagBits; |
| typedef VkFlags VkImageCreateFlags; |
| |
| typedef enum { |
| VK_SAMPLE_COUNT_1_BIT = 0x00000001, |
| VK_SAMPLE_COUNT_2_BIT = 0x00000002, |
| VK_SAMPLE_COUNT_4_BIT = 0x00000004, |
| VK_SAMPLE_COUNT_8_BIT = 0x00000008, |
| VK_SAMPLE_COUNT_16_BIT = 0x00000010, |
| VK_SAMPLE_COUNT_32_BIT = 0x00000020, |
| VK_SAMPLE_COUNT_64_BIT = 0x00000040, |
| } VkSampleCountFlagBits; |
| typedef VkFlags VkSampleCountFlags; |
| |
| typedef enum { |
| VK_QUEUE_GRAPHICS_BIT = 0x00000001, |
| VK_QUEUE_COMPUTE_BIT = 0x00000002, |
| VK_QUEUE_DMA_BIT = 0x00000004, |
| VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, |
| } VkQueueFlagBits; |
| typedef VkFlags VkQueueFlags; |
| |
| typedef enum { |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, |
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, |
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, |
| VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, |
| } VkMemoryPropertyFlagBits; |
| typedef VkFlags VkMemoryPropertyFlags; |
| |
| typedef enum { |
| VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, |
| } VkMemoryHeapFlagBits; |
| typedef VkFlags VkMemoryHeapFlags; |
| typedef VkFlags VkDeviceCreateFlags; |
| typedef VkFlags VkDeviceQueueCreateFlags; |
| typedef VkFlags VkMemoryMapFlags; |
| |
| typedef enum { |
| VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, |
| VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, |
| VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, |
| VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, |
| } VkImageAspectFlagBits; |
| |
| typedef enum { |
| VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, |
| VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, |
| VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, |
| } VkSparseImageFormatFlagBits; |
| typedef VkFlags VkSparseImageFormatFlags; |
| typedef VkFlags VkSparseMemoryBindFlags; |
| |
| typedef enum { |
| VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, |
| } VkFenceCreateFlagBits; |
| typedef VkFlags VkFenceCreateFlags; |
| typedef VkFlags VkSemaphoreCreateFlags; |
| typedef VkFlags VkEventCreateFlags; |
| typedef VkFlags VkQueryPoolCreateFlags; |
| |
| typedef enum { |
| VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, |
| VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, |
| VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, |
| VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, |
| VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, |
| VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, |
| VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, |
| VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, |
| VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, |
| VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, |
| VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_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_CREATE_SPARSE_BINDING_BIT = 0x00000001, |
| VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, |
| VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, |
| } VkBufferCreateFlagBits; |
| typedef VkFlags VkBufferCreateFlags; |
| |
| typedef enum { |
| VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, |
| VK_BUFFER_USAGE_TRANSFER_DST_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 VkFlags VkBufferViewCreateFlags; |
| typedef VkFlags VkImageViewCreateFlags; |
| typedef VkFlags VkImageAspectFlags; |
| typedef VkFlags VkShaderModuleCreateFlags; |
| typedef VkFlags VkShaderCreateFlags; |
| |
| typedef enum { |
| VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, |
| VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, |
| VK_SHADER_STAGE_TESSELLATION_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_GRAPHICS = 0x1F, |
| VK_SHADER_STAGE_ALL = 0x7FFFFFFF, |
| } VkShaderStageFlagBits; |
| typedef VkFlags VkPipelineCacheCreateFlags; |
| |
| 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 VkFlags VkPipelineShaderStageCreateFlags; |
| typedef VkFlags VkPipelineVertexInputStateCreateFlags; |
| typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; |
| typedef VkFlags VkPipelineTesselationStateCreateFlags; |
| typedef VkFlags VkPipelineViewportStateCreateFlags; |
| typedef VkFlags VkPipelineRasterizationStateCreateFlags; |
| |
| typedef enum { |
| VK_CULL_MODE_NONE = 0, |
| VK_CULL_MODE_FRONT_BIT = 0x00000001, |
| VK_CULL_MODE_BACK_BIT = 0x00000002, |
| VK_CULL_MODE_FRONT_AND_BACK = 0x3, |
| } VkCullModeFlagBits; |
| typedef VkFlags VkCullModeFlags; |
| typedef VkFlags VkPipelineMultisampleStateCreateFlags; |
| typedef VkFlags VkPipelineDepthStencilStateCreateFlags; |
| typedef VkFlags VkPipelineColorBlendStateCreateFlags; |
| |
| 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 VkFlags VkPipelineDynamicStateCreateFlags; |
| typedef VkFlags VkPipelineLayoutCreateFlags; |
| typedef VkFlags VkShaderStageFlags; |
| typedef VkFlags VkSamplerCreateFlags; |
| typedef VkFlags VkDescriptorSetLayoutCreateFlags; |
| |
| typedef enum { |
| VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, |
| } VkDescriptorPoolCreateFlagBits; |
| typedef VkFlags VkDescriptorPoolCreateFlags; |
| typedef VkFlags VkDescriptorPoolResetFlags; |
| typedef VkFlags VkFramebufferCreateFlags; |
| typedef VkFlags VkRenderPassCreateFlags; |
| |
| typedef enum { |
| VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, |
| } VkAttachmentDescriptionFlagBits; |
| typedef VkFlags VkAttachmentDescriptionFlags; |
| 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_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, |
| VK_PIPELINE_STAGE_TESSELLATION_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_HOST_BIT = 0x00002000, |
| VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, |
| VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, |
| } 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 enum { |
| VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, |
| } VkDependencyFlagBits; |
| typedef VkFlags VkDependencyFlags; |
| |
| typedef enum { |
| VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, |
| VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, |
| } VkCommandPoolCreateFlagBits; |
| typedef VkFlags VkCommandPoolCreateFlags; |
| |
| typedef enum { |
| VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, |
| } VkCommandPoolResetFlagBits; |
| typedef VkFlags VkCommandPoolResetFlags; |
| |
| typedef enum { |
| VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, |
| VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, |
| VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, |
| } VkCommandBufferUsageFlagBits; |
| typedef VkFlags VkCommandBufferUsageFlags; |
| |
| typedef enum { |
| VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, |
| } VkCommandBufferResetFlagBits; |
| typedef VkFlags VkCommandBufferResetFlags; |
| |
| typedef enum { |
| VK_STENCIL_FACE_NONE = 0, |
| VK_STENCIL_FACE_FRONT_BIT = 0x00000001, |
| VK_STENCIL_FACE_BACK_BIT = 0x00000002, |
| VK_STENCIL_FRONT_AND_BACK = 0x3, |
| } VkStencilFaceFlagBits; |
| typedef VkFlags VkStencilFaceFlags; |
| |
| typedef enum { |
| VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, |
| } VkQueryControlFlagBits; |
| typedef VkFlags VkQueryControlFlags; |
| |
| typedef void* (VKAPI *PFN_vkAllocationFunction)( |
| void* pUserData, |
| size_t size, |
| size_t alignment, |
| VkSystemAllocationScope allocationScope); |
| |
| typedef void* (VKAPI *PFN_vkReallocationFunction)( |
| void* pUserData, |
| void* pOriginal, |
| size_t size, |
| size_t alignment, |
| VkSystemAllocationScope allocationScope); |
| |
| typedef void (VKAPI *PFN_vkFreeFunction)( |
| void* pUserData, |
| void* pMemory); |
| |
| typedef void (VKAPI *PFN_vkInternalAllocationNotification)( |
| void* pUserData, |
| size_t size, |
| VkInternalAllocationType allocationType, |
| VkSystemAllocationScope allocationScope); |
| |
| typedef void (VKAPI *PFN_vkInternalFreeNotification)( |
| void* pUserData, |
| size_t size, |
| VkInternalAllocationType allocationType, |
| VkSystemAllocationScope allocationScope); |
| |
| typedef void (VKAPI *PFN_vkVoidFunction)(void); |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| const char* pApplicationName; |
| uint32_t applicationVersion; |
| const char* pEngineName; |
| uint32_t engineVersion; |
| uint32_t apiVersion; |
| } VkApplicationInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkInstanceCreateFlags flags; |
| const VkApplicationInfo* pApplicationInfo; |
| uint32_t enabledLayerNameCount; |
| const char*const* ppEnabledLayerNames; |
| uint32_t enabledExtensionNameCount; |
| const char*const* ppEnabledExtensionNames; |
| } VkInstanceCreateInfo; |
| |
| typedef struct { |
| void* pUserData; |
| PFN_vkAllocationFunction pfnAllocation; |
| PFN_vkReallocationFunction pfnReallocation; |
| PFN_vkFreeFunction pfnFree; |
| PFN_vkInternalAllocationNotification pfnInternalAllocation; |
| PFN_vkInternalFreeNotification pfnInternalFree; |
| } VkAllocationCallbacks; |
| |
| typedef struct { |
| VkBool32 robustBufferAccess; |
| VkBool32 fullDrawIndexUint32; |
| VkBool32 imageCubeArray; |
| VkBool32 independentBlend; |
| VkBool32 geometryShader; |
| VkBool32 tessellationShader; |
| VkBool32 sampleRateShading; |
| VkBool32 dualSrcBlend; |
| VkBool32 logicOp; |
| VkBool32 multiDrawIndirect; |
| VkBool32 depthClamp; |
| VkBool32 depthBiasClamp; |
| VkBool32 fillModeNonSolid; |
| VkBool32 depthBounds; |
| VkBool32 wideLines; |
| VkBool32 largePoints; |
| VkBool32 alphaToOne; |
| VkBool32 multiViewport; |
| VkBool32 samplerAnisotropy; |
| VkBool32 textureCompressionETC2; |
| VkBool32 textureCompressionASTC_LDR; |
| VkBool32 textureCompressionBC; |
| VkBool32 occlusionQueryNonConservative; |
| VkBool32 pipelineStatisticsQuery; |
| VkBool32 vertexPipelineStoresAndAtomics; |
| VkBool32 fragmentStoresAndAtomics; |
| VkBool32 shaderTessellationAndGeometryPointSize; |
| VkBool32 shaderImageGatherExtended; |
| VkBool32 shaderStorageImageExtendedFormats; |
| VkBool32 shaderStorageImageMultisample; |
| VkBool32 shaderStorageImageReadWithoutFormat; |
| VkBool32 shaderStorageImageWriteWithoutFormat; |
| VkBool32 shaderUniformBufferArrayDynamicIndexing; |
| VkBool32 shaderSampledImageArrayDynamicIndexing; |
| VkBool32 shaderStorageBufferArrayDynamicIndexing; |
| VkBool32 shaderStorageImageArrayDynamicIndexing; |
| VkBool32 shaderClipDistance; |
| VkBool32 shaderCullDistance; |
| VkBool32 shaderFloat64; |
| VkBool32 shaderInt64; |
| VkBool32 shaderInt16; |
| VkBool32 shaderResourceResidency; |
| VkBool32 shaderResourceMinLod; |
| VkBool32 sparseBinding; |
| VkBool32 sparseResidencyBuffer; |
| VkBool32 sparseResidencyImage2D; |
| VkBool32 sparseResidencyImage3D; |
| VkBool32 sparseResidency2Samples; |
| VkBool32 sparseResidency4Samples; |
| VkBool32 sparseResidency8Samples; |
| VkBool32 sparseResidency16Samples; |
| VkBool32 sparseResidencyAliased; |
| VkBool32 variableMultisampleRate; |
| } VkPhysicalDeviceFeatures; |
| |
| typedef struct { |
| VkFormatFeatureFlags linearTilingFeatures; |
| VkFormatFeatureFlags optimalTilingFeatures; |
| VkFormatFeatureFlags bufferFeatures; |
| } VkFormatProperties; |
| |
| typedef struct { |
| int32_t width; |
| int32_t height; |
| int32_t depth; |
| } VkExtent3D; |
| |
| typedef struct { |
| VkExtent3D maxExtent; |
| uint32_t maxMipLevels; |
| uint32_t maxArrayLayers; |
| VkSampleCountFlags sampleCounts; |
| VkDeviceSize maxResourceSize; |
| } VkImageFormatProperties; |
| |
| typedef struct { |
| uint32_t maxImageDimension1D; |
| uint32_t maxImageDimension2D; |
| uint32_t maxImageDimension3D; |
| uint32_t maxImageDimensionCube; |
| uint32_t maxImageArrayLayers; |
| VkSampleCountFlags sampleCounts; |
| uint32_t maxTexelBufferElements; |
| uint32_t maxUniformBufferRange; |
| uint32_t maxStorageBufferRange; |
| uint32_t maxPushConstantsSize; |
| uint32_t maxMemoryAllocationCount; |
| VkDeviceSize bufferImageGranularity; |
| VkDeviceSize sparseAddressSpaceSize; |
| uint32_t maxBoundDescriptorSets; |
| uint32_t maxPerStageDescriptorSamplers; |
| uint32_t maxPerStageDescriptorUniformBuffers; |
| uint32_t maxPerStageDescriptorStorageBuffers; |
| uint32_t maxPerStageDescriptorSampledImages; |
| uint32_t maxPerStageDescriptorStorageImages; |
| uint32_t maxDescriptorSetSamplers; |
| uint32_t maxDescriptorSetUniformBuffers; |
| uint32_t maxDescriptorSetUniformBuffersDynamic; |
| uint32_t maxDescriptorSetStorageBuffers; |
| uint32_t maxDescriptorSetStorageBuffersDynamic; |
| uint32_t maxDescriptorSetSampledImages; |
| uint32_t maxDescriptorSetStorageImages; |
| uint32_t maxVertexInputAttributes; |
| uint32_t maxVertexInputBindings; |
| uint32_t maxVertexInputAttributeOffset; |
| uint32_t maxVertexInputBindingStride; |
| uint32_t maxVertexOutputComponents; |
| uint32_t maxTessellationGenerationLevel; |
| uint32_t maxTessellationPatchSize; |
| uint32_t maxTessellationControlPerVertexInputComponents; |
| uint32_t maxTessellationControlPerVertexOutputComponents; |
| uint32_t maxTessellationControlPerPatchOutputComponents; |
| uint32_t maxTessellationControlTotalOutputComponents; |
| uint32_t maxTessellationEvaluationInputComponents; |
| uint32_t maxTessellationEvaluationOutputComponents; |
| uint32_t maxGeometryShaderInvocations; |
| uint32_t maxGeometryInputComponents; |
| uint32_t maxGeometryOutputComponents; |
| uint32_t maxGeometryOutputVertices; |
| uint32_t maxGeometryTotalOutputComponents; |
| uint32_t maxFragmentInputComponents; |
| uint32_t maxFragmentOutputAttachments; |
| uint32_t maxFragmentDualSrcAttachments; |
| 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; |
| float maxSamplerLodBias; |
| float maxSamplerAnisotropy; |
| uint32_t maxViewports; |
| uint32_t maxViewportDimensions[2]; |
| float viewportBoundsRange[2]; |
| uint32_t viewportSubPixelBits; |
| size_t minMemoryMapAlignment; |
| VkDeviceSize minTexelBufferOffsetAlignment; |
| VkDeviceSize minUniformBufferOffsetAlignment; |
| VkDeviceSize minStorageBufferOffsetAlignment; |
| int32_t minTexelOffset; |
| uint32_t maxTexelOffset; |
| int32_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 maxSampledImageStencilSamples; |
| uint32_t maxSampledImageIntegerSamples; |
| uint32_t maxStorageImageSamples; |
| uint32_t maxSampleMaskWords; |
| float timestampPeriod; |
| uint32_t maxClipDistances; |
| uint32_t maxCullDistances; |
| uint32_t maxCombinedClipAndCullDistances; |
| uint32_t discreteQueuePriorities; |
| float pointSizeRange[2]; |
| float lineWidthRange[2]; |
| float pointSizeGranularity; |
| float lineWidthGranularity; |
| VkBool32 strictLines; |
| VkDeviceSize recommendedBufferCopyOffsetAlignment; |
| VkDeviceSize recommendedBufferCopyRowPitchAlignment; |
| } VkPhysicalDeviceLimits; |
| |
| typedef struct { |
| VkBool32 residencyStandard2DBlockShape; |
| VkBool32 residencyStandard2DMultisampleBlockShape; |
| VkBool32 residencyStandard3DBlockShape; |
| VkBool32 residencyAlignedMipSize; |
| VkBool32 residencyNonResidentStrict; |
| } VkPhysicalDeviceSparseProperties; |
| |
| 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]; |
| VkPhysicalDeviceLimits limits; |
| VkPhysicalDeviceSparseProperties sparseProperties; |
| } VkPhysicalDeviceProperties; |
| |
| typedef struct { |
| VkQueueFlags queueFlags; |
| uint32_t queueCount; |
| uint32_t timestampValidBits; |
| VkExtent3D minImageTransferGranularity; |
| } VkQueueFamilyProperties; |
| |
| 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 struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceQueueCreateFlags flags; |
| uint32_t queueFamilyIndex; |
| uint32_t queuePriorityCount; |
| const float* pQueuePriorities; |
| } VkDeviceQueueCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceCreateFlags flags; |
| uint32_t requestedQueueCount; |
| const VkDeviceQueueCreateInfo* pRequestedQueues; |
| uint32_t enabledLayerNameCount; |
| const char*const* ppEnabledLayerNames; |
| uint32_t enabledExtensionNameCount; |
| const char*const* ppEnabledExtensionNames; |
| const VkPhysicalDeviceFeatures* pEnabledFeatures; |
| } VkDeviceCreateInfo; |
| |
| typedef struct { |
| char extensionName[VK_MAX_EXTENSION_NAME]; |
| uint32_t specVersion; |
| } VkExtensionProperties; |
| |
| typedef struct { |
| char layerName[VK_MAX_EXTENSION_NAME]; |
| uint32_t specVersion; |
| uint32_t implementationVersion; |
| char description[VK_MAX_DESCRIPTION]; |
| } VkLayerProperties; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t waitSemaphoreCount; |
| const VkSemaphore* pWaitSemaphores; |
| uint32_t commandBufferCount; |
| const VkCommandBuffer* pCommandBuffers; |
| uint32_t signalSemaphoreCount; |
| const VkSemaphore* pSignalSemaphores; |
| } VkSubmitInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceSize allocationSize; |
| uint32_t memoryTypeIndex; |
| } VkMemoryAllocateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceMemory memory; |
| VkDeviceSize offset; |
| VkDeviceSize size; |
| } VkMappedMemoryRange; |
| |
| typedef struct { |
| VkDeviceSize size; |
| VkDeviceSize alignment; |
| uint32_t memoryTypeBits; |
| } VkMemoryRequirements; |
| |
| typedef struct { |
| VkImageAspectFlagBits aspect; |
| VkExtent3D imageGranularity; |
| VkSparseImageFormatFlags flags; |
| } VkSparseImageFormatProperties; |
| |
| typedef struct { |
| VkSparseImageFormatProperties formatProperties; |
| uint32_t imageMipTailStartLod; |
| VkDeviceSize imageMipTailSize; |
| VkDeviceSize imageMipTailOffset; |
| VkDeviceSize imageMipTailStride; |
| } VkSparseImageMemoryRequirements; |
| |
| typedef struct { |
| VkDeviceSize resourceOffset; |
| VkDeviceSize size; |
| VkDeviceMemory memory; |
| VkDeviceSize memoryOffset; |
| VkSparseMemoryBindFlags flags; |
| } VkSparseMemoryBind; |
| |
| typedef struct { |
| VkBuffer buffer; |
| uint32_t bindCount; |
| const VkSparseMemoryBind* pBinds; |
| } VkSparseBufferMemoryBindInfo; |
| |
| typedef struct { |
| VkImage image; |
| uint32_t bindCount; |
| const VkSparseMemoryBind* pBinds; |
| } VkSparseImageOpaqueMemoryBindInfo; |
| |
| typedef struct { |
| VkImageAspectFlagBits aspect; |
| uint32_t mipLevel; |
| uint32_t arrayLayer; |
| } VkImageSubresource; |
| |
| typedef struct { |
| int32_t x; |
| int32_t y; |
| int32_t z; |
| } VkOffset3D; |
| |
| typedef struct { |
| VkImageSubresource subresource; |
| VkOffset3D offset; |
| VkExtent3D extent; |
| VkDeviceMemory memory; |
| VkDeviceSize memoryOffset; |
| VkSparseMemoryBindFlags flags; |
| } VkSparseImageMemoryBind; |
| |
| typedef struct { |
| VkImage image; |
| uint32_t bindCount; |
| const VkSparseImageMemoryBind* pBinds; |
| } VkSparseImageMemoryBindInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t waitSemaphoreCount; |
| const VkSemaphore* pWaitSemaphores; |
| uint32_t bufferBindCount; |
| const VkSparseBufferMemoryBindInfo* pBufferBinds; |
| uint32_t imageOpaqueBindCount; |
| const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; |
| uint32_t imageBindCount; |
| const VkSparseImageMemoryBindInfo* pImageBinds; |
| uint32_t signalSemaphoreCount; |
| const VkSemaphore* pSignalSemaphores; |
| } VkBindSparseInfo; |
| |
| 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; |
| VkQueryPoolCreateFlags flags; |
| VkQueryType queryType; |
| uint32_t slots; |
| VkQueryPipelineStatisticFlags pipelineStatistics; |
| } VkQueryPoolCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkBufferCreateFlags flags; |
| VkDeviceSize size; |
| VkBufferUsageFlags usage; |
| VkSharingMode sharingMode; |
| uint32_t queueFamilyIndexCount; |
| const uint32_t* pQueueFamilyIndices; |
| } VkBufferCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkBufferViewCreateFlags flags; |
| VkBuffer buffer; |
| VkFormat format; |
| VkDeviceSize offset; |
| VkDeviceSize range; |
| } VkBufferViewCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkImageCreateFlags flags; |
| VkImageType imageType; |
| VkFormat format; |
| VkExtent3D extent; |
| uint32_t mipLevels; |
| uint32_t arrayLayers; |
| uint32_t samples; |
| VkImageTiling tiling; |
| VkImageUsageFlags usage; |
| VkSharingMode sharingMode; |
| uint32_t queueFamilyIndexCount; |
| const uint32_t* pQueueFamilyIndices; |
| VkImageLayout initialLayout; |
| } 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 { |
| VkImageAspectFlags aspectMask; |
| uint32_t baseMipLevel; |
| uint32_t levelCount; |
| uint32_t baseArrayLayer; |
| uint32_t layerCount; |
| } VkImageSubresourceRange; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkImageViewCreateFlags flags; |
| VkImage image; |
| VkImageViewType viewType; |
| VkFormat format; |
| VkChannelMapping channels; |
| VkImageSubresourceRange subresourceRange; |
| } VkImageViewCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkShaderModuleCreateFlags flags; |
| size_t codeSize; |
| const uint32_t* pCode; |
| } VkShaderModuleCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkShaderCreateFlags flags; |
| VkShaderModule module; |
| const char* pName; |
| VkShaderStageFlagBits stage; |
| } VkShaderCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCacheCreateFlags flags; |
| size_t initialDataSize; |
| const void* pInitialData; |
| } VkPipelineCacheCreateInfo; |
| |
| typedef struct { |
| uint32_t constantID; |
| uint32_t offset; |
| size_t size; |
| } VkSpecializationMapEntry; |
| |
| typedef struct { |
| uint32_t mapEntryCount; |
| const VkSpecializationMapEntry* pMapEntries; |
| size_t dataSize; |
| const void* pData; |
| } VkSpecializationInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineShaderStageCreateFlags flags; |
| VkShader shader; |
| const VkSpecializationInfo* pSpecializationInfo; |
| } VkPipelineShaderStageCreateInfo; |
| |
| typedef struct { |
| uint32_t binding; |
| uint32_t stride; |
| VkVertexInputStepRate stepRate; |
| } VkVertexInputBindingDescription; |
| |
| typedef struct { |
| uint32_t location; |
| uint32_t binding; |
| VkFormat format; |
| uint32_t offset; |
| } VkVertexInputAttributeDescription; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineVertexInputStateCreateFlags flags; |
| uint32_t vertexBindingDescriptionCount; |
| const VkVertexInputBindingDescription* pVertexBindingDescriptions; |
| uint32_t vertexAttributeDescriptionCount; |
| const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; |
| } VkPipelineVertexInputStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineInputAssemblyStateCreateFlags flags; |
| VkPrimitiveTopology topology; |
| VkBool32 primitiveRestartEnable; |
| } VkPipelineInputAssemblyStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineTesselationStateCreateFlags flags; |
| uint32_t patchControlPoints; |
| } VkPipelineTessellationStateCreateInfo; |
| |
| 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; |
| VkPipelineViewportStateCreateFlags flags; |
| uint32_t viewportCount; |
| const VkViewport* pViewports; |
| uint32_t scissorCount; |
| const VkRect2D* pScissors; |
| } VkPipelineViewportStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineRasterizationStateCreateFlags flags; |
| VkBool32 depthClampEnable; |
| VkBool32 rasterizerDiscardEnable; |
| VkFillMode fillMode; |
| VkCullModeFlags cullMode; |
| VkFrontFace frontFace; |
| VkBool32 depthBiasEnable; |
| float depthBiasConstantFactor; |
| float depthBiasClamp; |
| float depthBiasSlopeFactor; |
| float lineWidth; |
| } VkPipelineRasterizationStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineMultisampleStateCreateFlags flags; |
| uint32_t rasterizationSamples; |
| VkBool32 sampleShadingEnable; |
| float minSampleShading; |
| const VkSampleMask* pSampleMask; |
| VkBool32 alphaToCoverageEnable; |
| VkBool32 alphaToOneEnable; |
| } VkPipelineMultisampleStateCreateInfo; |
| |
| typedef struct { |
| VkStencilOp stencilFailOp; |
| VkStencilOp stencilPassOp; |
| VkStencilOp stencilDepthFailOp; |
| VkCompareOp stencilCompareOp; |
| uint32_t stencilCompareMask; |
| uint32_t stencilWriteMask; |
| uint32_t stencilReference; |
| } VkStencilOpState; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineDepthStencilStateCreateFlags flags; |
| VkBool32 depthTestEnable; |
| VkBool32 depthWriteEnable; |
| VkCompareOp depthCompareOp; |
| VkBool32 depthBoundsTestEnable; |
| VkBool32 stencilTestEnable; |
| VkStencilOpState front; |
| VkStencilOpState back; |
| float minDepthBounds; |
| float maxDepthBounds; |
| } VkPipelineDepthStencilStateCreateInfo; |
| |
| typedef struct { |
| VkBool32 blendEnable; |
| VkBlend srcBlendColor; |
| VkBlend dstBlendColor; |
| VkBlendOp blendOpColor; |
| VkBlend srcBlendAlpha; |
| VkBlend dstBlendAlpha; |
| VkBlendOp blendOpAlpha; |
| VkChannelFlags channelWriteMask; |
| } VkPipelineColorBlendAttachmentState; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineColorBlendStateCreateFlags flags; |
| VkBool32 logicOpEnable; |
| VkLogicOp logicOp; |
| uint32_t attachmentCount; |
| const VkPipelineColorBlendAttachmentState* pAttachments; |
| float blendConstants[4]; |
| } VkPipelineColorBlendStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineDynamicStateCreateFlags flags; |
| uint32_t dynamicStateCount; |
| const VkDynamicState* pDynamicStates; |
| } VkPipelineDynamicStateCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCreateFlags flags; |
| uint32_t stageCount; |
| const VkPipelineShaderStageCreateInfo* pStages; |
| const VkPipelineVertexInputStateCreateInfo* pVertexInputState; |
| const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; |
| const VkPipelineTessellationStateCreateInfo* pTessellationState; |
| const VkPipelineViewportStateCreateInfo* pViewportState; |
| const VkPipelineRasterizationStateCreateInfo* pRasterizationState; |
| const VkPipelineMultisampleStateCreateInfo* pMultisampleState; |
| const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; |
| const VkPipelineColorBlendStateCreateInfo* pColorBlendState; |
| const VkPipelineDynamicStateCreateInfo* pDynamicState; |
| VkPipelineLayout layout; |
| VkRenderPass renderPass; |
| uint32_t subpass; |
| VkPipeline basePipelineHandle; |
| int32_t basePipelineIndex; |
| } VkGraphicsPipelineCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCreateFlags flags; |
| VkPipelineShaderStageCreateInfo stage; |
| VkPipelineLayout layout; |
| VkPipeline basePipelineHandle; |
| int32_t basePipelineIndex; |
| } VkComputePipelineCreateInfo; |
| |
| typedef struct { |
| VkShaderStageFlags stageFlags; |
| uint32_t offset; |
| uint32_t size; |
| } VkPushConstantRange; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineLayoutCreateFlags flags; |
| uint32_t setLayoutCount; |
| const VkDescriptorSetLayout* pSetLayouts; |
| uint32_t pushConstantRangeCount; |
| const VkPushConstantRange* pPushConstantRanges; |
| } VkPipelineLayoutCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkSamplerCreateFlags flags; |
| VkFilter magFilter; |
| VkFilter minFilter; |
| VkSamplerMipmapMode mipmapMode; |
| VkSamplerAddressMode addressModeU; |
| VkSamplerAddressMode addressModeV; |
| VkSamplerAddressMode addressModeW; |
| float mipLodBias; |
| float maxAnisotropy; |
| VkBool32 compareEnable; |
| VkCompareOp compareOp; |
| float minLod; |
| float maxLod; |
| VkBorderColor borderColor; |
| VkBool32 unnormalizedCoordinates; |
| } VkSamplerCreateInfo; |
| |
| typedef struct { |
| VkDescriptorType descriptorType; |
| uint32_t arraySize; |
| VkShaderStageFlags stageFlags; |
| const VkSampler* pImmutableSamplers; |
| } VkDescriptorSetLayoutBinding; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDescriptorSetLayoutCreateFlags flags; |
| uint32_t bindingCount; |
| const VkDescriptorSetLayoutBinding* pBindings; |
| } VkDescriptorSetLayoutCreateInfo; |
| |
| typedef struct { |
| VkDescriptorType type; |
| uint32_t descriptorCount; |
| } VkDescriptorTypeCount; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDescriptorPoolCreateFlags flags; |
| uint32_t maxSets; |
| uint32_t typeCount; |
| const VkDescriptorTypeCount* pTypeCounts; |
| } VkDescriptorPoolCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDescriptorPool descriptorPool; |
| uint32_t setLayoutCount; |
| const VkDescriptorSetLayout* pSetLayouts; |
| } VkDescriptorSetAllocateInfo; |
| |
| typedef struct { |
| VkSampler sampler; |
| VkImageView imageView; |
| VkImageLayout imageLayout; |
| } VkDescriptorImageInfo; |
| |
| typedef struct { |
| VkBuffer buffer; |
| VkDeviceSize offset; |
| VkDeviceSize range; |
| } VkDescriptorBufferInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDescriptorSet dstSet; |
| uint32_t dstBinding; |
| uint32_t dstArrayElement; |
| uint32_t descriptorCount; |
| VkDescriptorType descriptorType; |
| const VkDescriptorImageInfo* pImageInfo; |
| const VkDescriptorBufferInfo* pBufferInfo; |
| const VkBufferView* pTexelBufferView; |
| } VkWriteDescriptorSet; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkDescriptorSet srcSet; |
| uint32_t srcBinding; |
| uint32_t srcArrayElement; |
| VkDescriptorSet dstSet; |
| uint32_t dstBinding; |
| uint32_t dstArrayElement; |
| uint32_t descriptorCount; |
| } VkCopyDescriptorSet; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkFramebufferCreateFlags flags; |
| VkRenderPass renderPass; |
| uint32_t attachmentCount; |
| const VkImageView* pAttachments; |
| uint32_t width; |
| uint32_t height; |
| uint32_t layers; |
| } VkFramebufferCreateInfo; |
| |
| typedef struct { |
| VkAttachmentDescriptionFlags flags; |
| 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 { |
| VkSubpassDescriptionFlags flags; |
| VkPipelineBindPoint pipelineBindPoint; |
| uint32_t inputAttachmentCount; |
| const VkAttachmentReference* pInputAttachments; |
| uint32_t colorAttachmentCount; |
| const VkAttachmentReference* pColorAttachments; |
| const VkAttachmentReference* pResolveAttachments; |
| const VkAttachmentReference* pDepthStencilAttachment; |
| uint32_t preserveAttachmentCount; |
| const VkAttachmentReference* pPreserveAttachments; |
| } VkSubpassDescription; |
| |
| typedef struct { |
| uint32_t srcSubpass; |
| uint32_t dstSubpass; |
| VkPipelineStageFlags srcStageMask; |
| VkPipelineStageFlags dstStageMask; |
| VkMemoryOutputFlags outputMask; |
| VkMemoryInputFlags inputMask; |
| VkDependencyFlags dependencyFlags; |
| } VkSubpassDependency; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkRenderPassCreateFlags flags; |
| 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; |
| VkCommandPoolCreateFlags flags; |
| uint32_t queueFamilyIndex; |
| } VkCommandPoolCreateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkCommandPool commandPool; |
| VkCommandBufferLevel level; |
| uint32_t bufferCount; |
| } VkCommandBufferAllocateInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkCommandBufferUsageFlags flags; |
| VkRenderPass renderPass; |
| uint32_t subpass; |
| VkFramebuffer framebuffer; |
| } VkCommandBufferBeginInfo; |
| |
| typedef struct { |
| VkDeviceSize srcOffset; |
| VkDeviceSize dstOffset; |
| VkDeviceSize size; |
| } VkBufferCopy; |
| |
| typedef struct { |
| VkImageAspectFlags aspect; |
| uint32_t mipLevel; |
| uint32_t baseArrayLayer; |
| uint32_t layerCount; |
| } VkImageSubresourceCopy; |
| |
| typedef struct { |
| VkImageSubresourceCopy srcSubresource; |
| VkOffset3D srcOffset; |
| VkImageSubresourceCopy dstSubresource; |
| VkOffset3D dstOffset; |
| VkExtent3D extent; |
| } VkImageCopy; |
| |
| typedef struct { |
| VkImageSubresourceCopy srcSubresource; |
| VkOffset3D srcOffset; |
| VkExtent3D srcExtent; |
| VkImageSubresourceCopy dstSubresource; |
| VkOffset3D dstOffset; |
| VkExtent3D dstExtent; |
| } VkImageBlit; |
| |
| typedef struct { |
| VkDeviceSize bufferOffset; |
| uint32_t bufferRowLength; |
| uint32_t bufferImageHeight; |
| VkImageSubresourceCopy imageSubresource; |
| VkOffset3D imageOffset; |
| VkExtent3D imageExtent; |
| } VkBufferImageCopy; |
| |
| typedef union { |
| float float32[4]; |
| int32_t int32[4]; |
| uint32_t uint32[4]; |
| } VkClearColorValue; |
| |
| typedef struct { |
| float depth; |
| uint32_t stencil; |
| } VkClearDepthStencilValue; |
| |
| typedef union { |
| VkClearColorValue color; |
| VkClearDepthStencilValue depthStencil; |
| } VkClearValue; |
| |
| typedef struct { |
| VkImageAspectFlags aspectMask; |
| uint32_t colorAttachment; |
| VkClearValue clearValue; |
| } VkClearAttachment; |
| |
| typedef struct { |
| VkRect2D rect; |
| uint32_t baseArrayLayer; |
| uint32_t layerCount; |
| } VkClearRect; |
| |
| typedef struct { |
| VkImageSubresourceCopy srcSubresource; |
| VkOffset3D srcOffset; |
| VkImageSubresourceCopy dstSubresource; |
| VkOffset3D dstOffset; |
| VkExtent3D extent; |
| } VkImageResolve; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkRenderPass renderPass; |
| VkFramebuffer framebuffer; |
| VkRect2D renderArea; |
| uint32_t clearValueCount; |
| const VkClearValue* pClearValues; |
| } VkRenderPassBeginInfo; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkMemoryOutputFlags outputMask; |
| VkMemoryInputFlags inputMask; |
| uint32_t srcQueueFamilyIndex; |
| uint32_t dstQueueFamilyIndex; |
| VkBuffer buffer; |
| VkDeviceSize offset; |
| VkDeviceSize size; |
| } VkBufferMemoryBarrier; |
| |
| typedef struct { |
| uint32_t x; |
| uint32_t y; |
| uint32_t z; |
| } VkDispatchIndirectCommand; |
| |
| typedef struct { |
| uint32_t indexCount; |
| uint32_t instanceCount; |
| uint32_t firstIndex; |
| int32_t vertexOffset; |
| uint32_t firstInstance; |
| } VkDrawIndexedIndirectCommand; |
| |
| typedef struct { |
| uint32_t vertexCount; |
| uint32_t instanceCount; |
| uint32_t firstVertex; |
| uint32_t firstInstance; |
| } VkDrawIndirectCommand; |
| |
| typedef struct { |
| VkStructureType sType; |
| const void* pNext; |
| VkMemoryOutputFlags outputMask; |
| VkMemoryInputFlags inputMask; |
| VkImageLayout oldLayout; |
| VkImageLayout newLayout; |
| uint32_t srcQueueFamilyIndex; |
| uint32_t dstQueueFamilyIndex; |
| 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, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); |
| typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); |
| 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, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); |
| typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); |
| typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); |
| typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); |
| typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); |
| typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); |
| typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); |
| typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); |
| typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); |
| typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); |
| typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); |
| typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); |
| typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); |
| typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); |
| typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); |
| typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); |
| typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); |
| typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); |
| typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); |
| typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); |
| typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); |
| typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); |
| typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); |
| typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); |
| 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, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); |
| typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); |
| typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); |
| 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, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); |
| typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); |
| typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); |
| typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); |
| typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); |
| typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); |
| typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); |
| typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); |
| typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); |
| typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader); |
| typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); |
| typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); |
| typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); |
| typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); |
| typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); |
| typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); |
| typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); |
| typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); |
| typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); |
| typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); |
| typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); |
| typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); |
| typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); |
| typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); |
| typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); |
| typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); |
| typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); |
| typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); |
| typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); |
| typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); |
| typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); |
| typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); |
| typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); |
| typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); |
| typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); |
| typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); |
| typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); |
| typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); |
| typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); |
| typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); |
| typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); |
| typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); |
| typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); |
| typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); |
| typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); |
| typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); |
| typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); |
| typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); |
| typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); |
| typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); |
| typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); |
| typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); |
| typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); |
| typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); |
| typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); |
| typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); |
| typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); |
| typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); |
| typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); |
| typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); |
| typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); |
| typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); |
| typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); |
| typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); |
| typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); |
| typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); |
| typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); |
| typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); |
| typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); |
| typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); |
| typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot); |
| typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); |
| typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot); |
| typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); |
| typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values); |
| typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); |
| typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents); |
| typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); |
| typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers); |
| |
| #ifdef VK_PROTOTYPES |
| VkResult VKAPI vkCreateInstance( |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance); |
| |
| void VKAPI vkDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices); |
| |
| void VKAPI vkGetPhysicalDeviceFeatures( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures* pFeatures); |
| |
| void VKAPI vkGetPhysicalDeviceFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties* pFormatProperties); |
| |
| void VKAPI vkGetPhysicalDeviceImageFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkImageType type, |
| VkImageTiling tiling, |
| VkImageUsageFlags usage, |
| VkImageCreateFlags flags, |
| VkImageFormatProperties* pImageFormatProperties); |
| |
| void VKAPI vkGetPhysicalDeviceProperties( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties* pProperties); |
| |
| void VKAPI vkGetPhysicalDeviceQueueFamilyProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties* pQueueFamilyProperties); |
| |
| void VKAPI vkGetPhysicalDeviceMemoryProperties( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties); |
| |
| 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, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice); |
| |
| void VKAPI vkDestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkEnumerateInstanceExtensionProperties( |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties); |
| |
| VkResult VKAPI vkEnumerateDeviceExtensionProperties( |
| VkPhysicalDevice physicalDevice, |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties); |
| |
| VkResult VKAPI vkEnumerateInstanceLayerProperties( |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties); |
| |
| VkResult VKAPI vkEnumerateDeviceLayerProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties); |
| |
| void VKAPI vkGetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue); |
| |
| VkResult VKAPI vkQueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence); |
| |
| VkResult VKAPI vkQueueWaitIdle( |
| VkQueue queue); |
| |
| VkResult VKAPI vkDeviceWaitIdle( |
| VkDevice device); |
| |
| VkResult VKAPI vkAllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory); |
| |
| void VKAPI vkFreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkMapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData); |
| |
| void VKAPI vkUnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory); |
| |
| VkResult VKAPI vkFlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges); |
| |
| VkResult VKAPI vkInvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges); |
| |
| void VKAPI vkGetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes); |
| |
| VkResult VKAPI vkBindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset); |
| |
| VkResult VKAPI vkBindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset); |
| |
| void VKAPI vkGetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void VKAPI vkGetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void VKAPI vkGetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements); |
| |
| void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkImageType type, |
| uint32_t samples, |
| VkImageUsageFlags usage, |
| VkImageTiling tiling, |
| uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties* pProperties); |
| |
| VkResult VKAPI vkQueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence); |
| |
| VkResult VKAPI vkCreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence); |
| |
| void VKAPI vkDestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator); |
| |
| 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, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore); |
| |
| void VKAPI vkDestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent); |
| |
| void VKAPI vkDestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator); |
| |
| 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, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool); |
| |
| void VKAPI vkDestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkGetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t startQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags); |
| |
| VkResult VKAPI vkCreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer); |
| |
| void VKAPI vkDestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView); |
| |
| void VKAPI vkDestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage); |
| |
| void VKAPI vkDestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void VKAPI vkGetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout); |
| |
| VkResult VKAPI vkCreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView); |
| |
| void VKAPI vkDestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule); |
| |
| void VKAPI vkDestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateShader( |
| VkDevice device, |
| const VkShaderCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShader* pShader); |
| |
| void VKAPI vkDestroyShader( |
| VkDevice device, |
| VkShader shader, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache); |
| |
| void VKAPI vkDestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkGetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData); |
| |
| VkResult VKAPI vkMergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches); |
| |
| VkResult VKAPI vkCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| VkResult VKAPI vkCreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| void VKAPI vkDestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout); |
| |
| void VKAPI vkDestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler); |
| |
| void VKAPI vkDestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout); |
| |
| void VKAPI vkDestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool); |
| |
| void VKAPI vkDestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags); |
| |
| VkResult VKAPI vkAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets); |
| |
| VkResult VKAPI vkFreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets); |
| |
| void VKAPI vkUpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies); |
| |
| VkResult VKAPI vkCreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer); |
| |
| void VKAPI vkDestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkCreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass); |
| |
| void VKAPI vkDestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void VKAPI vkGetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity); |
| |
| VkResult VKAPI vkCreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool); |
| |
| void VKAPI vkDestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VkResult VKAPI vkResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags); |
| |
| VkResult VKAPI vkAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers); |
| |
| void VKAPI vkFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| VkResult VKAPI vkBeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo); |
| |
| VkResult VKAPI vkEndCommandBuffer( |
| VkCommandBuffer commandBuffer); |
| |
| VkResult VKAPI vkResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags); |
| |
| void VKAPI vkCmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline); |
| |
| void VKAPI vkCmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, |
| const VkViewport* pViewports); |
| |
| void VKAPI vkCmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors); |
| |
| void VKAPI vkCmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth); |
| |
| void VKAPI vkCmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor); |
| |
| void VKAPI vkCmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]); |
| |
| void VKAPI vkCmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds); |
| |
| void VKAPI vkCmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t stencilCompareMask); |
| |
| void VKAPI vkCmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t stencilWriteMask); |
| |
| void VKAPI vkCmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t stencilReference); |
| |
| void VKAPI vkCmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets); |
| |
| void VKAPI vkCmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType); |
| |
| void VKAPI vkCmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t startBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets); |
| |
| void VKAPI vkCmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance); |
| |
| void VKAPI vkCmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance); |
| |
| void VKAPI vkCmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void VKAPI vkCmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void VKAPI vkCmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t x, |
| uint32_t y, |
| uint32_t z); |
| |
| void VKAPI vkCmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset); |
| |
| void VKAPI vkCmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions); |
| |
| void VKAPI vkCmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions); |
| |
| void VKAPI vkCmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter); |
| |
| void VKAPI vkCmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void VKAPI vkCmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void VKAPI vkCmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const uint32_t* pData); |
| |
| void VKAPI vkCmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data); |
| |
| void VKAPI vkCmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void VKAPI vkCmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void VKAPI vkCmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects); |
| |
| void VKAPI vkCmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions); |
| |
| void VKAPI vkCmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void VKAPI vkCmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void VKAPI vkCmdWaitEvents( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| uint32_t memoryBarrierCount, |
| const void* const* ppMemoryBarriers); |
| |
| void VKAPI vkCmdPipelineBarrier( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkDependencyFlags dependencyFlags, |
| uint32_t memoryBarrierCount, |
| const void* const* ppMemoryBarriers); |
| |
| void VKAPI vkCmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t slot, |
| VkQueryControlFlags flags); |
| |
| void VKAPI vkCmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t slot); |
| |
| void VKAPI vkCmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t startQuery, |
| uint32_t queryCount); |
| |
| void VKAPI vkCmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t slot); |
| |
| void VKAPI vkCmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t startQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags); |
| |
| void VKAPI vkCmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* values); |
| |
| void VKAPI vkCmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkRenderPassContents contents); |
| |
| void VKAPI vkCmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkRenderPassContents contents); |
| |
| void VKAPI vkCmdEndRenderPass( |
| VkCommandBuffer commandBuffer); |
| |
| void VKAPI vkCmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBuffersCount, |
| const VkCommandBuffer* pCommandBuffers); |
| #endif |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif |