OLD | NEW |
(Empty) | |
| 1 #ifndef __vulkan_h_ |
| 2 #define __vulkan_h_ 1 |
| 3 |
| 4 #ifdef __cplusplus |
| 5 extern "C" { |
| 6 #endif |
| 7 |
| 8 /* |
| 9 ** Copyright (c) 2015-2016 The Khronos Group Inc. |
| 10 ** |
| 11 ** Permission is hereby granted, free of charge, to any person obtaining a |
| 12 ** copy of this software and/or associated documentation files (the |
| 13 ** "Materials"), to deal in the Materials without restriction, including |
| 14 ** without limitation the rights to use, copy, modify, merge, publish, |
| 15 ** distribute, sublicense, and/or sell copies of the Materials, and to |
| 16 ** permit persons to whom the Materials are furnished to do so, subject to |
| 17 ** the following conditions: |
| 18 ** |
| 19 ** The above copyright notice and this permission notice shall be included |
| 20 ** in all copies or substantial portions of the Materials. |
| 21 ** |
| 22 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 23 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 24 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 25 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 26 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| 27 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| 28 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. |
| 29 */ |
| 30 |
| 31 /* |
| 32 ** This header is generated from the Khronos Vulkan XML API Registry. |
| 33 ** |
| 34 */ |
| 35 |
| 36 |
| 37 #define VK_VERSION_1_0 1 |
| 38 #include "vk_platform.h" |
| 39 |
| 40 #define VK_MAKE_VERSION(major, minor, patch) \ |
| 41 (((major) << 22) | ((minor) << 12) | (patch)) |
| 42 |
| 43 // Vulkan API version supported by this file |
| 44 #define VK_API_VERSION VK_MAKE_VERSION(1, 0, 3) |
| 45 |
| 46 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) |
| 47 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) |
| 48 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) |
| 49 |
| 50 #define VK_NULL_HANDLE 0 |
| 51 |
| 52 |
| 53 |
| 54 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; |
| 55 |
| 56 |
| 57 #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X6
4) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__
powerpc64__) |
| 58 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object#
#_T *object; |
| 59 #else |
| 60 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t objec
t; |
| 61 #endif |
| 62 |
| 63 |
| 64 |
| 65 typedef uint32_t VkFlags; |
| 66 typedef uint32_t VkBool32; |
| 67 typedef uint64_t VkDeviceSize; |
| 68 typedef uint32_t VkSampleMask; |
| 69 |
| 70 VK_DEFINE_HANDLE(VkInstance) |
| 71 VK_DEFINE_HANDLE(VkPhysicalDevice) |
| 72 VK_DEFINE_HANDLE(VkDevice) |
| 73 VK_DEFINE_HANDLE(VkQueue) |
| 74 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) |
| 75 VK_DEFINE_HANDLE(VkCommandBuffer) |
| 76 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) |
| 77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) |
| 78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) |
| 79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) |
| 80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) |
| 81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) |
| 82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) |
| 83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) |
| 84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) |
| 85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) |
| 86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) |
| 87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) |
| 88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) |
| 89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) |
| 90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) |
| 91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) |
| 92 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) |
| 93 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) |
| 94 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) |
| 95 |
| 96 #define VK_LOD_CLAMP_NONE 1000.0f |
| 97 #define VK_REMAINING_MIP_LEVELS (~0U) |
| 98 #define VK_REMAINING_ARRAY_LAYERS (~0U) |
| 99 #define VK_WHOLE_SIZE (~0ULL) |
| 100 #define VK_ATTACHMENT_UNUSED (~0U) |
| 101 #define VK_TRUE 1 |
| 102 #define VK_FALSE 0 |
| 103 #define VK_QUEUE_FAMILY_IGNORED (~0U) |
| 104 #define VK_SUBPASS_EXTERNAL (~0U) |
| 105 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 |
| 106 #define VK_UUID_SIZE 16 |
| 107 #define VK_MAX_MEMORY_TYPES 32 |
| 108 #define VK_MAX_MEMORY_HEAPS 16 |
| 109 #define VK_MAX_EXTENSION_NAME_SIZE 256 |
| 110 #define VK_MAX_DESCRIPTION_SIZE 256 |
| 111 |
| 112 |
| 113 typedef enum VkPipelineCacheHeaderVersion { |
| 114 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, |
| 115 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERS
ION_ONE, |
| 116 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSIO
N_ONE, |
| 117 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERS
ION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), |
| 118 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF |
| 119 } VkPipelineCacheHeaderVersion; |
| 120 |
| 121 typedef enum VkResult { |
| 122 VK_SUCCESS = 0, |
| 123 VK_NOT_READY = 1, |
| 124 VK_TIMEOUT = 2, |
| 125 VK_EVENT_SET = 3, |
| 126 VK_EVENT_RESET = 4, |
| 127 VK_INCOMPLETE = 5, |
| 128 VK_ERROR_OUT_OF_HOST_MEMORY = -1, |
| 129 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, |
| 130 VK_ERROR_INITIALIZATION_FAILED = -3, |
| 131 VK_ERROR_DEVICE_LOST = -4, |
| 132 VK_ERROR_MEMORY_MAP_FAILED = -5, |
| 133 VK_ERROR_LAYER_NOT_PRESENT = -6, |
| 134 VK_ERROR_EXTENSION_NOT_PRESENT = -7, |
| 135 VK_ERROR_FEATURE_NOT_PRESENT = -8, |
| 136 VK_ERROR_INCOMPATIBLE_DRIVER = -9, |
| 137 VK_ERROR_TOO_MANY_OBJECTS = -10, |
| 138 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, |
| 139 VK_ERROR_SURFACE_LOST_KHR = -1000000000, |
| 140 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, |
| 141 VK_SUBOPTIMAL_KHR = 1000001003, |
| 142 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, |
| 143 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, |
| 144 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, |
| 145 VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, |
| 146 VK_RESULT_END_RANGE = VK_INCOMPLETE, |
| 147 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1), |
| 148 VK_RESULT_MAX_ENUM = 0x7FFFFFFF |
| 149 } VkResult; |
| 150 |
| 151 typedef enum VkStructureType { |
| 152 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, |
| 153 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, |
| 154 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, |
| 155 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, |
| 156 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, |
| 157 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, |
| 158 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, |
| 159 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, |
| 160 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, |
| 161 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, |
| 162 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, |
| 163 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, |
| 164 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, |
| 165 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, |
| 166 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, |
| 167 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, |
| 168 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, |
| 169 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, |
| 170 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, |
| 171 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, |
| 172 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, |
| 173 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, |
| 174 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, |
| 175 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, |
| 176 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, |
| 177 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, |
| 178 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, |
| 179 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, |
| 180 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, |
| 181 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, |
| 182 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, |
| 183 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, |
| 184 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, |
| 185 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, |
| 186 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, |
| 187 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, |
| 188 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, |
| 189 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, |
| 190 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, |
| 191 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, |
| 192 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, |
| 193 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, |
| 194 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, |
| 195 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, |
| 196 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, |
| 197 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, |
| 198 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, |
| 199 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, |
| 200 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, |
| 201 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, |
| 202 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, |
| 203 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, |
| 204 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, |
| 205 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, |
| 206 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, |
| 207 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, |
| 208 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, |
| 209 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, |
| 210 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, |
| 211 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, |
| 212 VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, |
| 213 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, |
| 214 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, |
| 215 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
- VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), |
| 216 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 217 } VkStructureType; |
| 218 |
| 219 typedef enum VkSystemAllocationScope { |
| 220 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, |
| 221 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, |
| 222 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, |
| 223 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, |
| 224 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, |
| 225 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, |
| 226 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, |
| 227 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
- VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), |
| 228 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF |
| 229 } VkSystemAllocationScope; |
| 230 |
| 231 typedef enum VkInternalAllocationType { |
| 232 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, |
| 233 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUT
ABLE, |
| 234 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTAB
LE, |
| 235 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUT
ABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), |
| 236 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 237 } VkInternalAllocationType; |
| 238 |
| 239 typedef enum VkFormat { |
| 240 VK_FORMAT_UNDEFINED = 0, |
| 241 VK_FORMAT_R4G4_UNORM_PACK8 = 1, |
| 242 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, |
| 243 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, |
| 244 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, |
| 245 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, |
| 246 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, |
| 247 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, |
| 248 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, |
| 249 VK_FORMAT_R8_UNORM = 9, |
| 250 VK_FORMAT_R8_SNORM = 10, |
| 251 VK_FORMAT_R8_USCALED = 11, |
| 252 VK_FORMAT_R8_SSCALED = 12, |
| 253 VK_FORMAT_R8_UINT = 13, |
| 254 VK_FORMAT_R8_SINT = 14, |
| 255 VK_FORMAT_R8_SRGB = 15, |
| 256 VK_FORMAT_R8G8_UNORM = 16, |
| 257 VK_FORMAT_R8G8_SNORM = 17, |
| 258 VK_FORMAT_R8G8_USCALED = 18, |
| 259 VK_FORMAT_R8G8_SSCALED = 19, |
| 260 VK_FORMAT_R8G8_UINT = 20, |
| 261 VK_FORMAT_R8G8_SINT = 21, |
| 262 VK_FORMAT_R8G8_SRGB = 22, |
| 263 VK_FORMAT_R8G8B8_UNORM = 23, |
| 264 VK_FORMAT_R8G8B8_SNORM = 24, |
| 265 VK_FORMAT_R8G8B8_USCALED = 25, |
| 266 VK_FORMAT_R8G8B8_SSCALED = 26, |
| 267 VK_FORMAT_R8G8B8_UINT = 27, |
| 268 VK_FORMAT_R8G8B8_SINT = 28, |
| 269 VK_FORMAT_R8G8B8_SRGB = 29, |
| 270 VK_FORMAT_B8G8R8_UNORM = 30, |
| 271 VK_FORMAT_B8G8R8_SNORM = 31, |
| 272 VK_FORMAT_B8G8R8_USCALED = 32, |
| 273 VK_FORMAT_B8G8R8_SSCALED = 33, |
| 274 VK_FORMAT_B8G8R8_UINT = 34, |
| 275 VK_FORMAT_B8G8R8_SINT = 35, |
| 276 VK_FORMAT_B8G8R8_SRGB = 36, |
| 277 VK_FORMAT_R8G8B8A8_UNORM = 37, |
| 278 VK_FORMAT_R8G8B8A8_SNORM = 38, |
| 279 VK_FORMAT_R8G8B8A8_USCALED = 39, |
| 280 VK_FORMAT_R8G8B8A8_SSCALED = 40, |
| 281 VK_FORMAT_R8G8B8A8_UINT = 41, |
| 282 VK_FORMAT_R8G8B8A8_SINT = 42, |
| 283 VK_FORMAT_R8G8B8A8_SRGB = 43, |
| 284 VK_FORMAT_B8G8R8A8_UNORM = 44, |
| 285 VK_FORMAT_B8G8R8A8_SNORM = 45, |
| 286 VK_FORMAT_B8G8R8A8_USCALED = 46, |
| 287 VK_FORMAT_B8G8R8A8_SSCALED = 47, |
| 288 VK_FORMAT_B8G8R8A8_UINT = 48, |
| 289 VK_FORMAT_B8G8R8A8_SINT = 49, |
| 290 VK_FORMAT_B8G8R8A8_SRGB = 50, |
| 291 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, |
| 292 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, |
| 293 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, |
| 294 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, |
| 295 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, |
| 296 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, |
| 297 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, |
| 298 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, |
| 299 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, |
| 300 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, |
| 301 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, |
| 302 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, |
| 303 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, |
| 304 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, |
| 305 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, |
| 306 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, |
| 307 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, |
| 308 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, |
| 309 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, |
| 310 VK_FORMAT_R16_UNORM = 70, |
| 311 VK_FORMAT_R16_SNORM = 71, |
| 312 VK_FORMAT_R16_USCALED = 72, |
| 313 VK_FORMAT_R16_SSCALED = 73, |
| 314 VK_FORMAT_R16_UINT = 74, |
| 315 VK_FORMAT_R16_SINT = 75, |
| 316 VK_FORMAT_R16_SFLOAT = 76, |
| 317 VK_FORMAT_R16G16_UNORM = 77, |
| 318 VK_FORMAT_R16G16_SNORM = 78, |
| 319 VK_FORMAT_R16G16_USCALED = 79, |
| 320 VK_FORMAT_R16G16_SSCALED = 80, |
| 321 VK_FORMAT_R16G16_UINT = 81, |
| 322 VK_FORMAT_R16G16_SINT = 82, |
| 323 VK_FORMAT_R16G16_SFLOAT = 83, |
| 324 VK_FORMAT_R16G16B16_UNORM = 84, |
| 325 VK_FORMAT_R16G16B16_SNORM = 85, |
| 326 VK_FORMAT_R16G16B16_USCALED = 86, |
| 327 VK_FORMAT_R16G16B16_SSCALED = 87, |
| 328 VK_FORMAT_R16G16B16_UINT = 88, |
| 329 VK_FORMAT_R16G16B16_SINT = 89, |
| 330 VK_FORMAT_R16G16B16_SFLOAT = 90, |
| 331 VK_FORMAT_R16G16B16A16_UNORM = 91, |
| 332 VK_FORMAT_R16G16B16A16_SNORM = 92, |
| 333 VK_FORMAT_R16G16B16A16_USCALED = 93, |
| 334 VK_FORMAT_R16G16B16A16_SSCALED = 94, |
| 335 VK_FORMAT_R16G16B16A16_UINT = 95, |
| 336 VK_FORMAT_R16G16B16A16_SINT = 96, |
| 337 VK_FORMAT_R16G16B16A16_SFLOAT = 97, |
| 338 VK_FORMAT_R32_UINT = 98, |
| 339 VK_FORMAT_R32_SINT = 99, |
| 340 VK_FORMAT_R32_SFLOAT = 100, |
| 341 VK_FORMAT_R32G32_UINT = 101, |
| 342 VK_FORMAT_R32G32_SINT = 102, |
| 343 VK_FORMAT_R32G32_SFLOAT = 103, |
| 344 VK_FORMAT_R32G32B32_UINT = 104, |
| 345 VK_FORMAT_R32G32B32_SINT = 105, |
| 346 VK_FORMAT_R32G32B32_SFLOAT = 106, |
| 347 VK_FORMAT_R32G32B32A32_UINT = 107, |
| 348 VK_FORMAT_R32G32B32A32_SINT = 108, |
| 349 VK_FORMAT_R32G32B32A32_SFLOAT = 109, |
| 350 VK_FORMAT_R64_UINT = 110, |
| 351 VK_FORMAT_R64_SINT = 111, |
| 352 VK_FORMAT_R64_SFLOAT = 112, |
| 353 VK_FORMAT_R64G64_UINT = 113, |
| 354 VK_FORMAT_R64G64_SINT = 114, |
| 355 VK_FORMAT_R64G64_SFLOAT = 115, |
| 356 VK_FORMAT_R64G64B64_UINT = 116, |
| 357 VK_FORMAT_R64G64B64_SINT = 117, |
| 358 VK_FORMAT_R64G64B64_SFLOAT = 118, |
| 359 VK_FORMAT_R64G64B64A64_UINT = 119, |
| 360 VK_FORMAT_R64G64B64A64_SINT = 120, |
| 361 VK_FORMAT_R64G64B64A64_SFLOAT = 121, |
| 362 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, |
| 363 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, |
| 364 VK_FORMAT_D16_UNORM = 124, |
| 365 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, |
| 366 VK_FORMAT_D32_SFLOAT = 126, |
| 367 VK_FORMAT_S8_UINT = 127, |
| 368 VK_FORMAT_D16_UNORM_S8_UINT = 128, |
| 369 VK_FORMAT_D24_UNORM_S8_UINT = 129, |
| 370 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, |
| 371 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, |
| 372 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, |
| 373 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, |
| 374 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, |
| 375 VK_FORMAT_BC2_UNORM_BLOCK = 135, |
| 376 VK_FORMAT_BC2_SRGB_BLOCK = 136, |
| 377 VK_FORMAT_BC3_UNORM_BLOCK = 137, |
| 378 VK_FORMAT_BC3_SRGB_BLOCK = 138, |
| 379 VK_FORMAT_BC4_UNORM_BLOCK = 139, |
| 380 VK_FORMAT_BC4_SNORM_BLOCK = 140, |
| 381 VK_FORMAT_BC5_UNORM_BLOCK = 141, |
| 382 VK_FORMAT_BC5_SNORM_BLOCK = 142, |
| 383 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, |
| 384 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, |
| 385 VK_FORMAT_BC7_UNORM_BLOCK = 145, |
| 386 VK_FORMAT_BC7_SRGB_BLOCK = 146, |
| 387 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, |
| 388 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, |
| 389 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, |
| 390 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, |
| 391 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, |
| 392 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, |
| 393 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, |
| 394 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, |
| 395 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, |
| 396 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, |
| 397 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, |
| 398 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, |
| 399 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, |
| 400 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, |
| 401 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, |
| 402 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, |
| 403 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, |
| 404 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, |
| 405 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, |
| 406 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, |
| 407 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, |
| 408 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, |
| 409 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, |
| 410 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, |
| 411 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, |
| 412 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, |
| 413 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, |
| 414 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, |
| 415 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, |
| 416 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, |
| 417 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, |
| 418 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, |
| 419 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, |
| 420 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, |
| 421 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, |
| 422 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, |
| 423 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, |
| 424 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, |
| 425 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, |
| 426 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, |
| 427 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINE
D + 1), |
| 428 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF |
| 429 } VkFormat; |
| 430 |
| 431 typedef enum VkImageType { |
| 432 VK_IMAGE_TYPE_1D = 0, |
| 433 VK_IMAGE_TYPE_2D = 1, |
| 434 VK_IMAGE_TYPE_3D = 2, |
| 435 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, |
| 436 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, |
| 437 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), |
| 438 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 439 } VkImageType; |
| 440 |
| 441 typedef enum VkImageTiling { |
| 442 VK_IMAGE_TILING_OPTIMAL = 0, |
| 443 VK_IMAGE_TILING_LINEAR = 1, |
| 444 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, |
| 445 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, |
| 446 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIM
AL + 1), |
| 447 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF |
| 448 } VkImageTiling; |
| 449 |
| 450 typedef enum VkPhysicalDeviceType { |
| 451 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, |
| 452 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, |
| 453 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, |
| 454 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, |
| 455 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, |
| 456 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, |
| 457 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, |
| 458 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSI
CAL_DEVICE_TYPE_OTHER + 1), |
| 459 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 460 } VkPhysicalDeviceType; |
| 461 |
| 462 typedef enum VkQueryType { |
| 463 VK_QUERY_TYPE_OCCLUSION = 0, |
| 464 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, |
| 465 VK_QUERY_TYPE_TIMESTAMP = 2, |
| 466 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, |
| 467 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, |
| 468 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSIO
N + 1), |
| 469 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 470 } VkQueryType; |
| 471 |
| 472 typedef enum VkSharingMode { |
| 473 VK_SHARING_MODE_EXCLUSIVE = 0, |
| 474 VK_SHARING_MODE_CONCURRENT = 1, |
| 475 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, |
| 476 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, |
| 477 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_E
XCLUSIVE + 1), |
| 478 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF |
| 479 } VkSharingMode; |
| 480 |
| 481 typedef enum VkImageLayout { |
| 482 VK_IMAGE_LAYOUT_UNDEFINED = 0, |
| 483 VK_IMAGE_LAYOUT_GENERAL = 1, |
| 484 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, |
| 485 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, |
| 486 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, |
| 487 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, |
| 488 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, |
| 489 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, |
| 490 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, |
| 491 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, |
| 492 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, |
| 493 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, |
| 494 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYO
UT_UNDEFINED + 1), |
| 495 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF |
| 496 } VkImageLayout; |
| 497 |
| 498 typedef enum VkImageViewType { |
| 499 VK_IMAGE_VIEW_TYPE_1D = 0, |
| 500 VK_IMAGE_VIEW_TYPE_2D = 1, |
| 501 VK_IMAGE_VIEW_TYPE_3D = 2, |
| 502 VK_IMAGE_VIEW_TYPE_CUBE = 3, |
| 503 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, |
| 504 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, |
| 505 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, |
| 506 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, |
| 507 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, |
| 508 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VI
EW_TYPE_1D + 1), |
| 509 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 510 } VkImageViewType; |
| 511 |
| 512 typedef enum VkComponentSwizzle { |
| 513 VK_COMPONENT_SWIZZLE_IDENTITY = 0, |
| 514 VK_COMPONENT_SWIZZLE_ZERO = 1, |
| 515 VK_COMPONENT_SWIZZLE_ONE = 2, |
| 516 VK_COMPONENT_SWIZZLE_R = 3, |
| 517 VK_COMPONENT_SWIZZLE_G = 4, |
| 518 VK_COMPONENT_SWIZZLE_B = 5, |
| 519 VK_COMPONENT_SWIZZLE_A = 6, |
| 520 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, |
| 521 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, |
| 522 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWI
ZZLE_IDENTITY + 1), |
| 523 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF |
| 524 } VkComponentSwizzle; |
| 525 |
| 526 typedef enum VkVertexInputRate { |
| 527 VK_VERTEX_INPUT_RATE_VERTEX = 0, |
| 528 VK_VERTEX_INPUT_RATE_INSTANCE = 1, |
| 529 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, |
| 530 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, |
| 531 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX
_INPUT_RATE_VERTEX + 1), |
| 532 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF |
| 533 } VkVertexInputRate; |
| 534 |
| 535 typedef enum VkPrimitiveTopology { |
| 536 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, |
| 537 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, |
| 538 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, |
| 539 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, |
| 540 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, |
| 541 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, |
| 542 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, |
| 543 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, |
| 544 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, |
| 545 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, |
| 546 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, |
| 547 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, |
| 548 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, |
| 549 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PR
IMITIVE_TOPOLOGY_POINT_LIST + 1), |
| 550 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF |
| 551 } VkPrimitiveTopology; |
| 552 |
| 553 typedef enum VkPolygonMode { |
| 554 VK_POLYGON_MODE_FILL = 0, |
| 555 VK_POLYGON_MODE_LINE = 1, |
| 556 VK_POLYGON_MODE_POINT = 2, |
| 557 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, |
| 558 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, |
| 559 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL +
1), |
| 560 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF |
| 561 } VkPolygonMode; |
| 562 |
| 563 typedef enum VkFrontFace { |
| 564 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, |
| 565 VK_FRONT_FACE_CLOCKWISE = 1, |
| 566 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, |
| 567 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, |
| 568 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_
CLOCKWISE + 1), |
| 569 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF |
| 570 } VkFrontFace; |
| 571 |
| 572 typedef enum VkCompareOp { |
| 573 VK_COMPARE_OP_NEVER = 0, |
| 574 VK_COMPARE_OP_LESS = 1, |
| 575 VK_COMPARE_OP_EQUAL = 2, |
| 576 VK_COMPARE_OP_LESS_OR_EQUAL = 3, |
| 577 VK_COMPARE_OP_GREATER = 4, |
| 578 VK_COMPARE_OP_NOT_EQUAL = 5, |
| 579 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, |
| 580 VK_COMPARE_OP_ALWAYS = 7, |
| 581 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, |
| 582 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, |
| 583 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), |
| 584 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF |
| 585 } VkCompareOp; |
| 586 |
| 587 typedef enum VkStencilOp { |
| 588 VK_STENCIL_OP_KEEP = 0, |
| 589 VK_STENCIL_OP_ZERO = 1, |
| 590 VK_STENCIL_OP_REPLACE = 2, |
| 591 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, |
| 592 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, |
| 593 VK_STENCIL_OP_INVERT = 5, |
| 594 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, |
| 595 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, |
| 596 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, |
| 597 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, |
| 598 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP
_KEEP + 1), |
| 599 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF |
| 600 } VkStencilOp; |
| 601 |
| 602 typedef enum VkLogicOp { |
| 603 VK_LOGIC_OP_CLEAR = 0, |
| 604 VK_LOGIC_OP_AND = 1, |
| 605 VK_LOGIC_OP_AND_REVERSE = 2, |
| 606 VK_LOGIC_OP_COPY = 3, |
| 607 VK_LOGIC_OP_AND_INVERTED = 4, |
| 608 VK_LOGIC_OP_NO_OP = 5, |
| 609 VK_LOGIC_OP_XOR = 6, |
| 610 VK_LOGIC_OP_OR = 7, |
| 611 VK_LOGIC_OP_NOR = 8, |
| 612 VK_LOGIC_OP_EQUIVALENT = 9, |
| 613 VK_LOGIC_OP_INVERT = 10, |
| 614 VK_LOGIC_OP_OR_REVERSE = 11, |
| 615 VK_LOGIC_OP_COPY_INVERTED = 12, |
| 616 VK_LOGIC_OP_OR_INVERTED = 13, |
| 617 VK_LOGIC_OP_NAND = 14, |
| 618 VK_LOGIC_OP_SET = 15, |
| 619 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, |
| 620 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, |
| 621 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), |
| 622 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF |
| 623 } VkLogicOp; |
| 624 |
| 625 typedef enum VkBlendFactor { |
| 626 VK_BLEND_FACTOR_ZERO = 0, |
| 627 VK_BLEND_FACTOR_ONE = 1, |
| 628 VK_BLEND_FACTOR_SRC_COLOR = 2, |
| 629 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, |
| 630 VK_BLEND_FACTOR_DST_COLOR = 4, |
| 631 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, |
| 632 VK_BLEND_FACTOR_SRC_ALPHA = 6, |
| 633 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, |
| 634 VK_BLEND_FACTOR_DST_ALPHA = 8, |
| 635 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, |
| 636 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, |
| 637 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, |
| 638 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, |
| 639 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, |
| 640 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, |
| 641 VK_BLEND_FACTOR_SRC1_COLOR = 15, |
| 642 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, |
| 643 VK_BLEND_FACTOR_SRC1_ALPHA = 17, |
| 644 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, |
| 645 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, |
| 646 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, |
| 647 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEN
D_FACTOR_ZERO + 1), |
| 648 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF |
| 649 } VkBlendFactor; |
| 650 |
| 651 typedef enum VkBlendOp { |
| 652 VK_BLEND_OP_ADD = 0, |
| 653 VK_BLEND_OP_SUBTRACT = 1, |
| 654 VK_BLEND_OP_REVERSE_SUBTRACT = 2, |
| 655 VK_BLEND_OP_MIN = 3, |
| 656 VK_BLEND_OP_MAX = 4, |
| 657 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, |
| 658 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, |
| 659 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), |
| 660 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF |
| 661 } VkBlendOp; |
| 662 |
| 663 typedef enum VkDynamicState { |
| 664 VK_DYNAMIC_STATE_VIEWPORT = 0, |
| 665 VK_DYNAMIC_STATE_SCISSOR = 1, |
| 666 VK_DYNAMIC_STATE_LINE_WIDTH = 2, |
| 667 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, |
| 668 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, |
| 669 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, |
| 670 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, |
| 671 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, |
| 672 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, |
| 673 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, |
| 674 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, |
| 675 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAM
IC_STATE_VIEWPORT + 1), |
| 676 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF |
| 677 } VkDynamicState; |
| 678 |
| 679 typedef enum VkFilter { |
| 680 VK_FILTER_NEAREST = 0, |
| 681 VK_FILTER_LINEAR = 1, |
| 682 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, |
| 683 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, |
| 684 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), |
| 685 VK_FILTER_MAX_ENUM = 0x7FFFFFFF |
| 686 } VkFilter; |
| 687 |
| 688 typedef enum VkSamplerMipmapMode { |
| 689 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, |
| 690 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, |
| 691 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, |
| 692 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, |
| 693 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMP
LER_MIPMAP_MODE_NEAREST + 1), |
| 694 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF |
| 695 } VkSamplerMipmapMode; |
| 696 |
| 697 typedef enum VkSamplerAddressMode { |
| 698 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, |
| 699 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, |
| 700 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, |
| 701 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, |
| 702 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, |
| 703 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, |
| 704 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_
EDGE, |
| 705 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_T
O_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), |
| 706 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF |
| 707 } VkSamplerAddressMode; |
| 708 |
| 709 typedef enum VkBorderColor { |
| 710 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, |
| 711 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, |
| 712 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, |
| 713 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, |
| 714 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, |
| 715 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, |
| 716 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, |
| 717 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, |
| 718 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_C
OLOR_FLOAT_TRANSPARENT_BLACK + 1), |
| 719 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF |
| 720 } VkBorderColor; |
| 721 |
| 722 typedef enum VkDescriptorType { |
| 723 VK_DESCRIPTOR_TYPE_SAMPLER = 0, |
| 724 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, |
| 725 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, |
| 726 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, |
| 727 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, |
| 728 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, |
| 729 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, |
| 730 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, |
| 731 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, |
| 732 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, |
| 733 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, |
| 734 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, |
| 735 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, |
| 736 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DE
SCRIPTOR_TYPE_SAMPLER + 1), |
| 737 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 738 } VkDescriptorType; |
| 739 |
| 740 typedef enum VkAttachmentLoadOp { |
| 741 VK_ATTACHMENT_LOAD_OP_LOAD = 0, |
| 742 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, |
| 743 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, |
| 744 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, |
| 745 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, |
| 746 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATT
ACHMENT_LOAD_OP_LOAD + 1), |
| 747 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF |
| 748 } VkAttachmentLoadOp; |
| 749 |
| 750 typedef enum VkAttachmentStoreOp { |
| 751 VK_ATTACHMENT_STORE_OP_STORE = 0, |
| 752 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, |
| 753 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, |
| 754 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, |
| 755 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_A
TTACHMENT_STORE_OP_STORE + 1), |
| 756 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF |
| 757 } VkAttachmentStoreOp; |
| 758 |
| 759 typedef enum VkPipelineBindPoint { |
| 760 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, |
| 761 VK_PIPELINE_BIND_POINT_COMPUTE = 1, |
| 762 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, |
| 763 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, |
| 764 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIP
ELINE_BIND_POINT_GRAPHICS + 1), |
| 765 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF |
| 766 } VkPipelineBindPoint; |
| 767 |
| 768 typedef enum VkCommandBufferLevel { |
| 769 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, |
| 770 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, |
| 771 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, |
| 772 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, |
| 773 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK
_COMMAND_BUFFER_LEVEL_PRIMARY + 1), |
| 774 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF |
| 775 } VkCommandBufferLevel; |
| 776 |
| 777 typedef enum VkIndexType { |
| 778 VK_INDEX_TYPE_UINT16 = 0, |
| 779 VK_INDEX_TYPE_UINT32 = 1, |
| 780 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, |
| 781 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, |
| 782 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1)
, |
| 783 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF |
| 784 } VkIndexType; |
| 785 |
| 786 typedef enum VkSubpassContents { |
| 787 VK_SUBPASS_CONTENTS_INLINE = 0, |
| 788 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, |
| 789 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, |
| 790 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFER
S, |
| 791 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFF
ERS - VK_SUBPASS_CONTENTS_INLINE + 1), |
| 792 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF |
| 793 } VkSubpassContents; |
| 794 |
| 795 typedef VkFlags VkInstanceCreateFlags; |
| 796 |
| 797 typedef enum VkFormatFeatureFlagBits { |
| 798 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, |
| 799 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, |
| 800 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, |
| 801 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, |
| 802 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, |
| 803 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, |
| 804 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, |
| 805 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, |
| 806 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, |
| 807 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, |
| 808 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, |
| 809 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, |
| 810 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, |
| 811 } VkFormatFeatureFlagBits; |
| 812 typedef VkFlags VkFormatFeatureFlags; |
| 813 |
| 814 typedef enum VkImageUsageFlagBits { |
| 815 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, |
| 816 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, |
| 817 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, |
| 818 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, |
| 819 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, |
| 820 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, |
| 821 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, |
| 822 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, |
| 823 } VkImageUsageFlagBits; |
| 824 typedef VkFlags VkImageUsageFlags; |
| 825 |
| 826 typedef enum VkImageCreateFlagBits { |
| 827 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, |
| 828 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, |
| 829 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, |
| 830 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, |
| 831 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, |
| 832 } VkImageCreateFlagBits; |
| 833 typedef VkFlags VkImageCreateFlags; |
| 834 |
| 835 typedef enum VkSampleCountFlagBits { |
| 836 VK_SAMPLE_COUNT_1_BIT = 0x00000001, |
| 837 VK_SAMPLE_COUNT_2_BIT = 0x00000002, |
| 838 VK_SAMPLE_COUNT_4_BIT = 0x00000004, |
| 839 VK_SAMPLE_COUNT_8_BIT = 0x00000008, |
| 840 VK_SAMPLE_COUNT_16_BIT = 0x00000010, |
| 841 VK_SAMPLE_COUNT_32_BIT = 0x00000020, |
| 842 VK_SAMPLE_COUNT_64_BIT = 0x00000040, |
| 843 } VkSampleCountFlagBits; |
| 844 typedef VkFlags VkSampleCountFlags; |
| 845 |
| 846 typedef enum VkQueueFlagBits { |
| 847 VK_QUEUE_GRAPHICS_BIT = 0x00000001, |
| 848 VK_QUEUE_COMPUTE_BIT = 0x00000002, |
| 849 VK_QUEUE_TRANSFER_BIT = 0x00000004, |
| 850 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, |
| 851 } VkQueueFlagBits; |
| 852 typedef VkFlags VkQueueFlags; |
| 853 |
| 854 typedef enum VkMemoryPropertyFlagBits { |
| 855 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, |
| 856 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, |
| 857 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, |
| 858 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, |
| 859 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, |
| 860 } VkMemoryPropertyFlagBits; |
| 861 typedef VkFlags VkMemoryPropertyFlags; |
| 862 |
| 863 typedef enum VkMemoryHeapFlagBits { |
| 864 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, |
| 865 } VkMemoryHeapFlagBits; |
| 866 typedef VkFlags VkMemoryHeapFlags; |
| 867 typedef VkFlags VkDeviceCreateFlags; |
| 868 typedef VkFlags VkDeviceQueueCreateFlags; |
| 869 |
| 870 typedef enum VkPipelineStageFlagBits { |
| 871 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, |
| 872 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, |
| 873 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, |
| 874 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, |
| 875 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, |
| 876 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, |
| 877 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, |
| 878 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, |
| 879 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, |
| 880 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, |
| 881 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, |
| 882 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, |
| 883 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, |
| 884 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, |
| 885 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, |
| 886 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, |
| 887 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, |
| 888 } VkPipelineStageFlagBits; |
| 889 typedef VkFlags VkPipelineStageFlags; |
| 890 typedef VkFlags VkMemoryMapFlags; |
| 891 |
| 892 typedef enum VkImageAspectFlagBits { |
| 893 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, |
| 894 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, |
| 895 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, |
| 896 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, |
| 897 } VkImageAspectFlagBits; |
| 898 typedef VkFlags VkImageAspectFlags; |
| 899 |
| 900 typedef enum VkSparseImageFormatFlagBits { |
| 901 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, |
| 902 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, |
| 903 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, |
| 904 } VkSparseImageFormatFlagBits; |
| 905 typedef VkFlags VkSparseImageFormatFlags; |
| 906 |
| 907 typedef enum VkSparseMemoryBindFlagBits { |
| 908 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, |
| 909 } VkSparseMemoryBindFlagBits; |
| 910 typedef VkFlags VkSparseMemoryBindFlags; |
| 911 |
| 912 typedef enum VkFenceCreateFlagBits { |
| 913 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, |
| 914 } VkFenceCreateFlagBits; |
| 915 typedef VkFlags VkFenceCreateFlags; |
| 916 typedef VkFlags VkSemaphoreCreateFlags; |
| 917 typedef VkFlags VkEventCreateFlags; |
| 918 typedef VkFlags VkQueryPoolCreateFlags; |
| 919 |
| 920 typedef enum VkQueryPipelineStatisticFlagBits { |
| 921 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, |
| 922 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, |
| 923 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, |
| 924 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, |
| 925 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, |
| 926 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, |
| 927 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, |
| 928 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, |
| 929 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x0000
0100, |
| 930 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT =
0x00000200, |
| 931 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, |
| 932 } VkQueryPipelineStatisticFlagBits; |
| 933 typedef VkFlags VkQueryPipelineStatisticFlags; |
| 934 |
| 935 typedef enum VkQueryResultFlagBits { |
| 936 VK_QUERY_RESULT_64_BIT = 0x00000001, |
| 937 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, |
| 938 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, |
| 939 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, |
| 940 } VkQueryResultFlagBits; |
| 941 typedef VkFlags VkQueryResultFlags; |
| 942 |
| 943 typedef enum VkBufferCreateFlagBits { |
| 944 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, |
| 945 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, |
| 946 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, |
| 947 } VkBufferCreateFlagBits; |
| 948 typedef VkFlags VkBufferCreateFlags; |
| 949 |
| 950 typedef enum VkBufferUsageFlagBits { |
| 951 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, |
| 952 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, |
| 953 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, |
| 954 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, |
| 955 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, |
| 956 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, |
| 957 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, |
| 958 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, |
| 959 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, |
| 960 } VkBufferUsageFlagBits; |
| 961 typedef VkFlags VkBufferUsageFlags; |
| 962 typedef VkFlags VkBufferViewCreateFlags; |
| 963 typedef VkFlags VkImageViewCreateFlags; |
| 964 typedef VkFlags VkShaderModuleCreateFlags; |
| 965 typedef VkFlags VkPipelineCacheCreateFlags; |
| 966 |
| 967 typedef enum VkPipelineCreateFlagBits { |
| 968 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, |
| 969 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, |
| 970 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, |
| 971 } VkPipelineCreateFlagBits; |
| 972 typedef VkFlags VkPipelineCreateFlags; |
| 973 typedef VkFlags VkPipelineShaderStageCreateFlags; |
| 974 |
| 975 typedef enum VkShaderStageFlagBits { |
| 976 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, |
| 977 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, |
| 978 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, |
| 979 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, |
| 980 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, |
| 981 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, |
| 982 VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, |
| 983 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, |
| 984 } VkShaderStageFlagBits; |
| 985 typedef VkFlags VkPipelineVertexInputStateCreateFlags; |
| 986 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; |
| 987 typedef VkFlags VkPipelineTessellationStateCreateFlags; |
| 988 typedef VkFlags VkPipelineViewportStateCreateFlags; |
| 989 typedef VkFlags VkPipelineRasterizationStateCreateFlags; |
| 990 |
| 991 typedef enum VkCullModeFlagBits { |
| 992 VK_CULL_MODE_NONE = 0, |
| 993 VK_CULL_MODE_FRONT_BIT = 0x00000001, |
| 994 VK_CULL_MODE_BACK_BIT = 0x00000002, |
| 995 VK_CULL_MODE_FRONT_AND_BACK = 0x3, |
| 996 } VkCullModeFlagBits; |
| 997 typedef VkFlags VkCullModeFlags; |
| 998 typedef VkFlags VkPipelineMultisampleStateCreateFlags; |
| 999 typedef VkFlags VkPipelineDepthStencilStateCreateFlags; |
| 1000 typedef VkFlags VkPipelineColorBlendStateCreateFlags; |
| 1001 |
| 1002 typedef enum VkColorComponentFlagBits { |
| 1003 VK_COLOR_COMPONENT_R_BIT = 0x00000001, |
| 1004 VK_COLOR_COMPONENT_G_BIT = 0x00000002, |
| 1005 VK_COLOR_COMPONENT_B_BIT = 0x00000004, |
| 1006 VK_COLOR_COMPONENT_A_BIT = 0x00000008, |
| 1007 } VkColorComponentFlagBits; |
| 1008 typedef VkFlags VkColorComponentFlags; |
| 1009 typedef VkFlags VkPipelineDynamicStateCreateFlags; |
| 1010 typedef VkFlags VkPipelineLayoutCreateFlags; |
| 1011 typedef VkFlags VkShaderStageFlags; |
| 1012 typedef VkFlags VkSamplerCreateFlags; |
| 1013 typedef VkFlags VkDescriptorSetLayoutCreateFlags; |
| 1014 |
| 1015 typedef enum VkDescriptorPoolCreateFlagBits { |
| 1016 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, |
| 1017 } VkDescriptorPoolCreateFlagBits; |
| 1018 typedef VkFlags VkDescriptorPoolCreateFlags; |
| 1019 typedef VkFlags VkDescriptorPoolResetFlags; |
| 1020 typedef VkFlags VkFramebufferCreateFlags; |
| 1021 typedef VkFlags VkRenderPassCreateFlags; |
| 1022 |
| 1023 typedef enum VkAttachmentDescriptionFlagBits { |
| 1024 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, |
| 1025 } VkAttachmentDescriptionFlagBits; |
| 1026 typedef VkFlags VkAttachmentDescriptionFlags; |
| 1027 typedef VkFlags VkSubpassDescriptionFlags; |
| 1028 |
| 1029 typedef enum VkAccessFlagBits { |
| 1030 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, |
| 1031 VK_ACCESS_INDEX_READ_BIT = 0x00000002, |
| 1032 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, |
| 1033 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, |
| 1034 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, |
| 1035 VK_ACCESS_SHADER_READ_BIT = 0x00000020, |
| 1036 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, |
| 1037 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, |
| 1038 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, |
| 1039 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, |
| 1040 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, |
| 1041 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, |
| 1042 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, |
| 1043 VK_ACCESS_HOST_READ_BIT = 0x00002000, |
| 1044 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, |
| 1045 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, |
| 1046 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, |
| 1047 } VkAccessFlagBits; |
| 1048 typedef VkFlags VkAccessFlags; |
| 1049 |
| 1050 typedef enum VkDependencyFlagBits { |
| 1051 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, |
| 1052 } VkDependencyFlagBits; |
| 1053 typedef VkFlags VkDependencyFlags; |
| 1054 |
| 1055 typedef enum VkCommandPoolCreateFlagBits { |
| 1056 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, |
| 1057 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, |
| 1058 } VkCommandPoolCreateFlagBits; |
| 1059 typedef VkFlags VkCommandPoolCreateFlags; |
| 1060 |
| 1061 typedef enum VkCommandPoolResetFlagBits { |
| 1062 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, |
| 1063 } VkCommandPoolResetFlagBits; |
| 1064 typedef VkFlags VkCommandPoolResetFlags; |
| 1065 |
| 1066 typedef enum VkCommandBufferUsageFlagBits { |
| 1067 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, |
| 1068 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, |
| 1069 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, |
| 1070 } VkCommandBufferUsageFlagBits; |
| 1071 typedef VkFlags VkCommandBufferUsageFlags; |
| 1072 |
| 1073 typedef enum VkQueryControlFlagBits { |
| 1074 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, |
| 1075 } VkQueryControlFlagBits; |
| 1076 typedef VkFlags VkQueryControlFlags; |
| 1077 |
| 1078 typedef enum VkCommandBufferResetFlagBits { |
| 1079 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, |
| 1080 } VkCommandBufferResetFlagBits; |
| 1081 typedef VkFlags VkCommandBufferResetFlags; |
| 1082 |
| 1083 typedef enum VkStencilFaceFlagBits { |
| 1084 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, |
| 1085 VK_STENCIL_FACE_BACK_BIT = 0x00000002, |
| 1086 VK_STENCIL_FRONT_AND_BACK = 0x3, |
| 1087 } VkStencilFaceFlagBits; |
| 1088 typedef VkFlags VkStencilFaceFlags; |
| 1089 |
| 1090 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( |
| 1091 void* pUserData, |
| 1092 size_t size, |
| 1093 size_t alignment, |
| 1094 VkSystemAllocationScope allocationScope); |
| 1095 |
| 1096 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( |
| 1097 void* pUserData, |
| 1098 void* pOriginal, |
| 1099 size_t size, |
| 1100 size_t alignment, |
| 1101 VkSystemAllocationScope allocationScope); |
| 1102 |
| 1103 typedef void (VKAPI_PTR *PFN_vkFreeFunction)( |
| 1104 void* pUserData, |
| 1105 void* pMemory); |
| 1106 |
| 1107 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( |
| 1108 void* pUserData, |
| 1109 size_t size, |
| 1110 VkInternalAllocationType allocationType, |
| 1111 VkSystemAllocationScope allocationScope); |
| 1112 |
| 1113 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( |
| 1114 void* pUserData, |
| 1115 size_t size, |
| 1116 VkInternalAllocationType allocationType, |
| 1117 VkSystemAllocationScope allocationScope); |
| 1118 |
| 1119 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); |
| 1120 |
| 1121 typedef struct VkApplicationInfo { |
| 1122 VkStructureType sType; |
| 1123 const void* pNext; |
| 1124 const char* pApplicationName; |
| 1125 uint32_t applicationVersion; |
| 1126 const char* pEngineName; |
| 1127 uint32_t engineVersion; |
| 1128 uint32_t apiVersion; |
| 1129 } VkApplicationInfo; |
| 1130 |
| 1131 typedef struct VkInstanceCreateInfo { |
| 1132 VkStructureType sType; |
| 1133 const void* pNext; |
| 1134 VkInstanceCreateFlags flags; |
| 1135 const VkApplicationInfo* pApplicationInfo; |
| 1136 uint32_t enabledLayerCount; |
| 1137 const char* const* ppEnabledLayerNames; |
| 1138 uint32_t enabledExtensionCount; |
| 1139 const char* const* ppEnabledExtensionNames; |
| 1140 } VkInstanceCreateInfo; |
| 1141 |
| 1142 typedef struct VkAllocationCallbacks { |
| 1143 void* pUserData; |
| 1144 PFN_vkAllocationFunction pfnAllocation; |
| 1145 PFN_vkReallocationFunction pfnReallocation; |
| 1146 PFN_vkFreeFunction pfnFree; |
| 1147 PFN_vkInternalAllocationNotification pfnInternalAllocation; |
| 1148 PFN_vkInternalFreeNotification pfnInternalFree; |
| 1149 } VkAllocationCallbacks; |
| 1150 |
| 1151 typedef struct VkPhysicalDeviceFeatures { |
| 1152 VkBool32 robustBufferAccess; |
| 1153 VkBool32 fullDrawIndexUint32; |
| 1154 VkBool32 imageCubeArray; |
| 1155 VkBool32 independentBlend; |
| 1156 VkBool32 geometryShader; |
| 1157 VkBool32 tessellationShader; |
| 1158 VkBool32 sampleRateShading; |
| 1159 VkBool32 dualSrcBlend; |
| 1160 VkBool32 logicOp; |
| 1161 VkBool32 multiDrawIndirect; |
| 1162 VkBool32 drawIndirectFirstInstance; |
| 1163 VkBool32 depthClamp; |
| 1164 VkBool32 depthBiasClamp; |
| 1165 VkBool32 fillModeNonSolid; |
| 1166 VkBool32 depthBounds; |
| 1167 VkBool32 wideLines; |
| 1168 VkBool32 largePoints; |
| 1169 VkBool32 alphaToOne; |
| 1170 VkBool32 multiViewport; |
| 1171 VkBool32 samplerAnisotropy; |
| 1172 VkBool32 textureCompressionETC2; |
| 1173 VkBool32 textureCompressionASTC_LDR; |
| 1174 VkBool32 textureCompressionBC; |
| 1175 VkBool32 occlusionQueryPrecise; |
| 1176 VkBool32 pipelineStatisticsQuery; |
| 1177 VkBool32 vertexPipelineStoresAndAtomics; |
| 1178 VkBool32 fragmentStoresAndAtomics; |
| 1179 VkBool32 shaderTessellationAndGeometryPointSize; |
| 1180 VkBool32 shaderImageGatherExtended; |
| 1181 VkBool32 shaderStorageImageExtendedFormats; |
| 1182 VkBool32 shaderStorageImageMultisample; |
| 1183 VkBool32 shaderStorageImageReadWithoutFormat; |
| 1184 VkBool32 shaderStorageImageWriteWithoutFormat; |
| 1185 VkBool32 shaderUniformBufferArrayDynamicIndexing; |
| 1186 VkBool32 shaderSampledImageArrayDynamicIndexing; |
| 1187 VkBool32 shaderStorageBufferArrayDynamicIndexing; |
| 1188 VkBool32 shaderStorageImageArrayDynamicIndexing; |
| 1189 VkBool32 shaderClipDistance; |
| 1190 VkBool32 shaderCullDistance; |
| 1191 VkBool32 shaderFloat64; |
| 1192 VkBool32 shaderInt64; |
| 1193 VkBool32 shaderInt16; |
| 1194 VkBool32 shaderResourceResidency; |
| 1195 VkBool32 shaderResourceMinLod; |
| 1196 VkBool32 sparseBinding; |
| 1197 VkBool32 sparseResidencyBuffer; |
| 1198 VkBool32 sparseResidencyImage2D; |
| 1199 VkBool32 sparseResidencyImage3D; |
| 1200 VkBool32 sparseResidency2Samples; |
| 1201 VkBool32 sparseResidency4Samples; |
| 1202 VkBool32 sparseResidency8Samples; |
| 1203 VkBool32 sparseResidency16Samples; |
| 1204 VkBool32 sparseResidencyAliased; |
| 1205 VkBool32 variableMultisampleRate; |
| 1206 VkBool32 inheritedQueries; |
| 1207 } VkPhysicalDeviceFeatures; |
| 1208 |
| 1209 typedef struct VkFormatProperties { |
| 1210 VkFormatFeatureFlags linearTilingFeatures; |
| 1211 VkFormatFeatureFlags optimalTilingFeatures; |
| 1212 VkFormatFeatureFlags bufferFeatures; |
| 1213 } VkFormatProperties; |
| 1214 |
| 1215 typedef struct VkExtent3D { |
| 1216 uint32_t width; |
| 1217 uint32_t height; |
| 1218 uint32_t depth; |
| 1219 } VkExtent3D; |
| 1220 |
| 1221 typedef struct VkImageFormatProperties { |
| 1222 VkExtent3D maxExtent; |
| 1223 uint32_t maxMipLevels; |
| 1224 uint32_t maxArrayLayers; |
| 1225 VkSampleCountFlags sampleCounts; |
| 1226 VkDeviceSize maxResourceSize; |
| 1227 } VkImageFormatProperties; |
| 1228 |
| 1229 typedef struct VkPhysicalDeviceLimits { |
| 1230 uint32_t maxImageDimension1D; |
| 1231 uint32_t maxImageDimension2D; |
| 1232 uint32_t maxImageDimension3D; |
| 1233 uint32_t maxImageDimensionCube; |
| 1234 uint32_t maxImageArrayLayers; |
| 1235 uint32_t maxTexelBufferElements; |
| 1236 uint32_t maxUniformBufferRange; |
| 1237 uint32_t maxStorageBufferRange; |
| 1238 uint32_t maxPushConstantsSize; |
| 1239 uint32_t maxMemoryAllocationCount; |
| 1240 uint32_t maxSamplerAllocationCount; |
| 1241 VkDeviceSize bufferImageGranularity; |
| 1242 VkDeviceSize sparseAddressSpaceSize; |
| 1243 uint32_t maxBoundDescriptorSets; |
| 1244 uint32_t maxPerStageDescriptorSamplers; |
| 1245 uint32_t maxPerStageDescriptorUniformBuffers; |
| 1246 uint32_t maxPerStageDescriptorStorageBuffers; |
| 1247 uint32_t maxPerStageDescriptorSampledImages; |
| 1248 uint32_t maxPerStageDescriptorStorageImages; |
| 1249 uint32_t maxPerStageDescriptorInputAttachments; |
| 1250 uint32_t maxPerStageResources; |
| 1251 uint32_t maxDescriptorSetSamplers; |
| 1252 uint32_t maxDescriptorSetUniformBuffers; |
| 1253 uint32_t maxDescriptorSetUniformBuffersDynamic; |
| 1254 uint32_t maxDescriptorSetStorageBuffers; |
| 1255 uint32_t maxDescriptorSetStorageBuffersDynamic; |
| 1256 uint32_t maxDescriptorSetSampledImages; |
| 1257 uint32_t maxDescriptorSetStorageImages; |
| 1258 uint32_t maxDescriptorSetInputAttachments; |
| 1259 uint32_t maxVertexInputAttributes; |
| 1260 uint32_t maxVertexInputBindings; |
| 1261 uint32_t maxVertexInputAttributeOffset; |
| 1262 uint32_t maxVertexInputBindingStride; |
| 1263 uint32_t maxVertexOutputComponents; |
| 1264 uint32_t maxTessellationGenerationLevel; |
| 1265 uint32_t maxTessellationPatchSize; |
| 1266 uint32_t maxTessellationControlPerVertexInputComponents; |
| 1267 uint32_t maxTessellationControlPerVertexOutputComponents; |
| 1268 uint32_t maxTessellationControlPerPatchOutputComponents; |
| 1269 uint32_t maxTessellationControlTotalOutputComponents; |
| 1270 uint32_t maxTessellationEvaluationInputComponents; |
| 1271 uint32_t maxTessellationEvaluationOutputComponents; |
| 1272 uint32_t maxGeometryShaderInvocations; |
| 1273 uint32_t maxGeometryInputComponents; |
| 1274 uint32_t maxGeometryOutputComponents; |
| 1275 uint32_t maxGeometryOutputVertices; |
| 1276 uint32_t maxGeometryTotalOutputComponents; |
| 1277 uint32_t maxFragmentInputComponents; |
| 1278 uint32_t maxFragmentOutputAttachments; |
| 1279 uint32_t maxFragmentDualSrcAttachments; |
| 1280 uint32_t maxFragmentCombinedOutputResources; |
| 1281 uint32_t maxComputeSharedMemorySize; |
| 1282 uint32_t maxComputeWorkGroupCount[3]; |
| 1283 uint32_t maxComputeWorkGroupInvocations; |
| 1284 uint32_t maxComputeWorkGroupSize[3]; |
| 1285 uint32_t subPixelPrecisionBits; |
| 1286 uint32_t subTexelPrecisionBits; |
| 1287 uint32_t mipmapPrecisionBits; |
| 1288 uint32_t maxDrawIndexedIndexValue; |
| 1289 uint32_t maxDrawIndirectCount; |
| 1290 float maxSamplerLodBias; |
| 1291 float maxSamplerAnisotropy; |
| 1292 uint32_t maxViewports; |
| 1293 uint32_t maxViewportDimensions[2]; |
| 1294 float viewportBoundsRange[2]; |
| 1295 uint32_t viewportSubPixelBits; |
| 1296 size_t minMemoryMapAlignment; |
| 1297 VkDeviceSize minTexelBufferOffsetAlignment; |
| 1298 VkDeviceSize minUniformBufferOffsetAlignment; |
| 1299 VkDeviceSize minStorageBufferOffsetAlignment; |
| 1300 int32_t minTexelOffset; |
| 1301 uint32_t maxTexelOffset; |
| 1302 int32_t minTexelGatherOffset; |
| 1303 uint32_t maxTexelGatherOffset; |
| 1304 float minInterpolationOffset; |
| 1305 float maxInterpolationOffset; |
| 1306 uint32_t subPixelInterpolationOffsetBits; |
| 1307 uint32_t maxFramebufferWidth; |
| 1308 uint32_t maxFramebufferHeight; |
| 1309 uint32_t maxFramebufferLayers; |
| 1310 VkSampleCountFlags framebufferColorSampleCounts; |
| 1311 VkSampleCountFlags framebufferDepthSampleCounts; |
| 1312 VkSampleCountFlags framebufferStencilSampleCounts; |
| 1313 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; |
| 1314 uint32_t maxColorAttachments; |
| 1315 VkSampleCountFlags sampledImageColorSampleCounts; |
| 1316 VkSampleCountFlags sampledImageIntegerSampleCounts; |
| 1317 VkSampleCountFlags sampledImageDepthSampleCounts; |
| 1318 VkSampleCountFlags sampledImageStencilSampleCounts; |
| 1319 VkSampleCountFlags storageImageSampleCounts; |
| 1320 uint32_t maxSampleMaskWords; |
| 1321 VkBool32 timestampComputeAndGraphics; |
| 1322 float timestampPeriod; |
| 1323 uint32_t maxClipDistances; |
| 1324 uint32_t maxCullDistances; |
| 1325 uint32_t maxCombinedClipAndCullDistances; |
| 1326 uint32_t discreteQueuePriorities; |
| 1327 float pointSizeRange[2]; |
| 1328 float lineWidthRange[2]; |
| 1329 float pointSizeGranularity; |
| 1330 float lineWidthGranularity; |
| 1331 VkBool32 strictLines; |
| 1332 VkBool32 standardSampleLocations; |
| 1333 VkDeviceSize optimalBufferCopyOffsetAlignment; |
| 1334 VkDeviceSize optimalBufferCopyRowPitchAlignment; |
| 1335 VkDeviceSize nonCoherentAtomSize; |
| 1336 } VkPhysicalDeviceLimits; |
| 1337 |
| 1338 typedef struct VkPhysicalDeviceSparseProperties { |
| 1339 VkBool32 residencyStandard2DBlockShape; |
| 1340 VkBool32 residencyStandard2DMultisampleBlockShape; |
| 1341 VkBool32 residencyStandard3DBlockShape; |
| 1342 VkBool32 residencyAlignedMipSize; |
| 1343 VkBool32 residencyNonResidentStrict; |
| 1344 } VkPhysicalDeviceSparseProperties; |
| 1345 |
| 1346 typedef struct VkPhysicalDeviceProperties { |
| 1347 uint32_t apiVersion; |
| 1348 uint32_t driverVersion; |
| 1349 uint32_t vendorID; |
| 1350 uint32_t deviceID; |
| 1351 VkPhysicalDeviceType deviceType; |
| 1352 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_S
IZE]; |
| 1353 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; |
| 1354 VkPhysicalDeviceLimits limits; |
| 1355 VkPhysicalDeviceSparseProperties sparseProperties; |
| 1356 } VkPhysicalDeviceProperties; |
| 1357 |
| 1358 typedef struct VkQueueFamilyProperties { |
| 1359 VkQueueFlags queueFlags; |
| 1360 uint32_t queueCount; |
| 1361 uint32_t timestampValidBits; |
| 1362 VkExtent3D minImageTransferGranularity; |
| 1363 } VkQueueFamilyProperties; |
| 1364 |
| 1365 typedef struct VkMemoryType { |
| 1366 VkMemoryPropertyFlags propertyFlags; |
| 1367 uint32_t heapIndex; |
| 1368 } VkMemoryType; |
| 1369 |
| 1370 typedef struct VkMemoryHeap { |
| 1371 VkDeviceSize size; |
| 1372 VkMemoryHeapFlags flags; |
| 1373 } VkMemoryHeap; |
| 1374 |
| 1375 typedef struct VkPhysicalDeviceMemoryProperties { |
| 1376 uint32_t memoryTypeCount; |
| 1377 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; |
| 1378 uint32_t memoryHeapCount; |
| 1379 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; |
| 1380 } VkPhysicalDeviceMemoryProperties; |
| 1381 |
| 1382 typedef struct VkDeviceQueueCreateInfo { |
| 1383 VkStructureType sType; |
| 1384 const void* pNext; |
| 1385 VkDeviceQueueCreateFlags flags; |
| 1386 uint32_t queueFamilyIndex; |
| 1387 uint32_t queueCount; |
| 1388 const float* pQueuePriorities; |
| 1389 } VkDeviceQueueCreateInfo; |
| 1390 |
| 1391 typedef struct VkDeviceCreateInfo { |
| 1392 VkStructureType sType; |
| 1393 const void* pNext; |
| 1394 VkDeviceCreateFlags flags; |
| 1395 uint32_t queueCreateInfoCount; |
| 1396 const VkDeviceQueueCreateInfo* pQueueCreateInfos; |
| 1397 uint32_t enabledLayerCount; |
| 1398 const char* const* ppEnabledLayerNames; |
| 1399 uint32_t enabledExtensionCount; |
| 1400 const char* const* ppEnabledExtensionNames; |
| 1401 const VkPhysicalDeviceFeatures* pEnabledFeatures; |
| 1402 } VkDeviceCreateInfo; |
| 1403 |
| 1404 typedef struct VkExtensionProperties { |
| 1405 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; |
| 1406 uint32_t specVersion; |
| 1407 } VkExtensionProperties; |
| 1408 |
| 1409 typedef struct VkLayerProperties { |
| 1410 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; |
| 1411 uint32_t specVersion; |
| 1412 uint32_t implementationVersion; |
| 1413 char description[VK_MAX_DESCRIPTION_SIZE]; |
| 1414 } VkLayerProperties; |
| 1415 |
| 1416 typedef struct VkSubmitInfo { |
| 1417 VkStructureType sType; |
| 1418 const void* pNext; |
| 1419 uint32_t waitSemaphoreCount; |
| 1420 const VkSemaphore* pWaitSemaphores; |
| 1421 const VkPipelineStageFlags* pWaitDstStageMask; |
| 1422 uint32_t commandBufferCount; |
| 1423 const VkCommandBuffer* pCommandBuffers; |
| 1424 uint32_t signalSemaphoreCount; |
| 1425 const VkSemaphore* pSignalSemaphores; |
| 1426 } VkSubmitInfo; |
| 1427 |
| 1428 typedef struct VkMemoryAllocateInfo { |
| 1429 VkStructureType sType; |
| 1430 const void* pNext; |
| 1431 VkDeviceSize allocationSize; |
| 1432 uint32_t memoryTypeIndex; |
| 1433 } VkMemoryAllocateInfo; |
| 1434 |
| 1435 typedef struct VkMappedMemoryRange { |
| 1436 VkStructureType sType; |
| 1437 const void* pNext; |
| 1438 VkDeviceMemory memory; |
| 1439 VkDeviceSize offset; |
| 1440 VkDeviceSize size; |
| 1441 } VkMappedMemoryRange; |
| 1442 |
| 1443 typedef struct VkMemoryRequirements { |
| 1444 VkDeviceSize size; |
| 1445 VkDeviceSize alignment; |
| 1446 uint32_t memoryTypeBits; |
| 1447 } VkMemoryRequirements; |
| 1448 |
| 1449 typedef struct VkSparseImageFormatProperties { |
| 1450 VkImageAspectFlags aspectMask; |
| 1451 VkExtent3D imageGranularity; |
| 1452 VkSparseImageFormatFlags flags; |
| 1453 } VkSparseImageFormatProperties; |
| 1454 |
| 1455 typedef struct VkSparseImageMemoryRequirements { |
| 1456 VkSparseImageFormatProperties formatProperties; |
| 1457 uint32_t imageMipTailFirstLod; |
| 1458 VkDeviceSize imageMipTailSize; |
| 1459 VkDeviceSize imageMipTailOffset; |
| 1460 VkDeviceSize imageMipTailStride; |
| 1461 } VkSparseImageMemoryRequirements; |
| 1462 |
| 1463 typedef struct VkSparseMemoryBind { |
| 1464 VkDeviceSize resourceOffset; |
| 1465 VkDeviceSize size; |
| 1466 VkDeviceMemory memory; |
| 1467 VkDeviceSize memoryOffset; |
| 1468 VkSparseMemoryBindFlags flags; |
| 1469 } VkSparseMemoryBind; |
| 1470 |
| 1471 typedef struct VkSparseBufferMemoryBindInfo { |
| 1472 VkBuffer buffer; |
| 1473 uint32_t bindCount; |
| 1474 const VkSparseMemoryBind* pBinds; |
| 1475 } VkSparseBufferMemoryBindInfo; |
| 1476 |
| 1477 typedef struct VkSparseImageOpaqueMemoryBindInfo { |
| 1478 VkImage image; |
| 1479 uint32_t bindCount; |
| 1480 const VkSparseMemoryBind* pBinds; |
| 1481 } VkSparseImageOpaqueMemoryBindInfo; |
| 1482 |
| 1483 typedef struct VkImageSubresource { |
| 1484 VkImageAspectFlags aspectMask; |
| 1485 uint32_t mipLevel; |
| 1486 uint32_t arrayLayer; |
| 1487 } VkImageSubresource; |
| 1488 |
| 1489 typedef struct VkOffset3D { |
| 1490 int32_t x; |
| 1491 int32_t y; |
| 1492 int32_t z; |
| 1493 } VkOffset3D; |
| 1494 |
| 1495 typedef struct VkSparseImageMemoryBind { |
| 1496 VkImageSubresource subresource; |
| 1497 VkOffset3D offset; |
| 1498 VkExtent3D extent; |
| 1499 VkDeviceMemory memory; |
| 1500 VkDeviceSize memoryOffset; |
| 1501 VkSparseMemoryBindFlags flags; |
| 1502 } VkSparseImageMemoryBind; |
| 1503 |
| 1504 typedef struct VkSparseImageMemoryBindInfo { |
| 1505 VkImage image; |
| 1506 uint32_t bindCount; |
| 1507 const VkSparseImageMemoryBind* pBinds; |
| 1508 } VkSparseImageMemoryBindInfo; |
| 1509 |
| 1510 typedef struct VkBindSparseInfo { |
| 1511 VkStructureType sType; |
| 1512 const void* pNext; |
| 1513 uint32_t waitSemaphoreCount; |
| 1514 const VkSemaphore* pWaitSemaphores; |
| 1515 uint32_t bufferBindCount; |
| 1516 const VkSparseBufferMemoryBindInfo* pBufferBinds; |
| 1517 uint32_t imageOpaqueBindCount; |
| 1518 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; |
| 1519 uint32_t imageBindCount; |
| 1520 const VkSparseImageMemoryBindInfo* pImageBinds; |
| 1521 uint32_t signalSemaphoreCount; |
| 1522 const VkSemaphore* pSignalSemaphores; |
| 1523 } VkBindSparseInfo; |
| 1524 |
| 1525 typedef struct VkFenceCreateInfo { |
| 1526 VkStructureType sType; |
| 1527 const void* pNext; |
| 1528 VkFenceCreateFlags flags; |
| 1529 } VkFenceCreateInfo; |
| 1530 |
| 1531 typedef struct VkSemaphoreCreateInfo { |
| 1532 VkStructureType sType; |
| 1533 const void* pNext; |
| 1534 VkSemaphoreCreateFlags flags; |
| 1535 } VkSemaphoreCreateInfo; |
| 1536 |
| 1537 typedef struct VkEventCreateInfo { |
| 1538 VkStructureType sType; |
| 1539 const void* pNext; |
| 1540 VkEventCreateFlags flags; |
| 1541 } VkEventCreateInfo; |
| 1542 |
| 1543 typedef struct VkQueryPoolCreateInfo { |
| 1544 VkStructureType sType; |
| 1545 const void* pNext; |
| 1546 VkQueryPoolCreateFlags flags; |
| 1547 VkQueryType queryType; |
| 1548 uint32_t queryCount; |
| 1549 VkQueryPipelineStatisticFlags pipelineStatistics; |
| 1550 } VkQueryPoolCreateInfo; |
| 1551 |
| 1552 typedef struct VkBufferCreateInfo { |
| 1553 VkStructureType sType; |
| 1554 const void* pNext; |
| 1555 VkBufferCreateFlags flags; |
| 1556 VkDeviceSize size; |
| 1557 VkBufferUsageFlags usage; |
| 1558 VkSharingMode sharingMode; |
| 1559 uint32_t queueFamilyIndexCount; |
| 1560 const uint32_t* pQueueFamilyIndices; |
| 1561 } VkBufferCreateInfo; |
| 1562 |
| 1563 typedef struct VkBufferViewCreateInfo { |
| 1564 VkStructureType sType; |
| 1565 const void* pNext; |
| 1566 VkBufferViewCreateFlags flags; |
| 1567 VkBuffer buffer; |
| 1568 VkFormat format; |
| 1569 VkDeviceSize offset; |
| 1570 VkDeviceSize range; |
| 1571 } VkBufferViewCreateInfo; |
| 1572 |
| 1573 typedef struct VkImageCreateInfo { |
| 1574 VkStructureType sType; |
| 1575 const void* pNext; |
| 1576 VkImageCreateFlags flags; |
| 1577 VkImageType imageType; |
| 1578 VkFormat format; |
| 1579 VkExtent3D extent; |
| 1580 uint32_t mipLevels; |
| 1581 uint32_t arrayLayers; |
| 1582 VkSampleCountFlagBits samples; |
| 1583 VkImageTiling tiling; |
| 1584 VkImageUsageFlags usage; |
| 1585 VkSharingMode sharingMode; |
| 1586 uint32_t queueFamilyIndexCount; |
| 1587 const uint32_t* pQueueFamilyIndices; |
| 1588 VkImageLayout initialLayout; |
| 1589 } VkImageCreateInfo; |
| 1590 |
| 1591 typedef struct VkSubresourceLayout { |
| 1592 VkDeviceSize offset; |
| 1593 VkDeviceSize size; |
| 1594 VkDeviceSize rowPitch; |
| 1595 VkDeviceSize arrayPitch; |
| 1596 VkDeviceSize depthPitch; |
| 1597 } VkSubresourceLayout; |
| 1598 |
| 1599 typedef struct VkComponentMapping { |
| 1600 VkComponentSwizzle r; |
| 1601 VkComponentSwizzle g; |
| 1602 VkComponentSwizzle b; |
| 1603 VkComponentSwizzle a; |
| 1604 } VkComponentMapping; |
| 1605 |
| 1606 typedef struct VkImageSubresourceRange { |
| 1607 VkImageAspectFlags aspectMask; |
| 1608 uint32_t baseMipLevel; |
| 1609 uint32_t levelCount; |
| 1610 uint32_t baseArrayLayer; |
| 1611 uint32_t layerCount; |
| 1612 } VkImageSubresourceRange; |
| 1613 |
| 1614 typedef struct VkImageViewCreateInfo { |
| 1615 VkStructureType sType; |
| 1616 const void* pNext; |
| 1617 VkImageViewCreateFlags flags; |
| 1618 VkImage image; |
| 1619 VkImageViewType viewType; |
| 1620 VkFormat format; |
| 1621 VkComponentMapping components; |
| 1622 VkImageSubresourceRange subresourceRange; |
| 1623 } VkImageViewCreateInfo; |
| 1624 |
| 1625 typedef struct VkShaderModuleCreateInfo { |
| 1626 VkStructureType sType; |
| 1627 const void* pNext; |
| 1628 VkShaderModuleCreateFlags flags; |
| 1629 size_t codeSize; |
| 1630 const uint32_t* pCode; |
| 1631 } VkShaderModuleCreateInfo; |
| 1632 |
| 1633 typedef struct VkPipelineCacheCreateInfo { |
| 1634 VkStructureType sType; |
| 1635 const void* pNext; |
| 1636 VkPipelineCacheCreateFlags flags; |
| 1637 size_t initialDataSize; |
| 1638 const void* pInitialData; |
| 1639 } VkPipelineCacheCreateInfo; |
| 1640 |
| 1641 typedef struct VkSpecializationMapEntry { |
| 1642 uint32_t constantID; |
| 1643 uint32_t offset; |
| 1644 size_t size; |
| 1645 } VkSpecializationMapEntry; |
| 1646 |
| 1647 typedef struct VkSpecializationInfo { |
| 1648 uint32_t mapEntryCount; |
| 1649 const VkSpecializationMapEntry* pMapEntries; |
| 1650 size_t dataSize; |
| 1651 const void* pData; |
| 1652 } VkSpecializationInfo; |
| 1653 |
| 1654 typedef struct VkPipelineShaderStageCreateInfo { |
| 1655 VkStructureType sType; |
| 1656 const void* pNext; |
| 1657 VkPipelineShaderStageCreateFlags flags; |
| 1658 VkShaderStageFlagBits stage; |
| 1659 VkShaderModule module; |
| 1660 const char* pName; |
| 1661 const VkSpecializationInfo* pSpecializationInfo; |
| 1662 } VkPipelineShaderStageCreateInfo; |
| 1663 |
| 1664 typedef struct VkVertexInputBindingDescription { |
| 1665 uint32_t binding; |
| 1666 uint32_t stride; |
| 1667 VkVertexInputRate inputRate; |
| 1668 } VkVertexInputBindingDescription; |
| 1669 |
| 1670 typedef struct VkVertexInputAttributeDescription { |
| 1671 uint32_t location; |
| 1672 uint32_t binding; |
| 1673 VkFormat format; |
| 1674 uint32_t offset; |
| 1675 } VkVertexInputAttributeDescription; |
| 1676 |
| 1677 typedef struct VkPipelineVertexInputStateCreateInfo { |
| 1678 VkStructureType sType; |
| 1679 const void* pNext; |
| 1680 VkPipelineVertexInputStateCreateFlags flags; |
| 1681 uint32_t vertexBindingDescriptionCount; |
| 1682 const VkVertexInputBindingDescription* pVertexBindingDescriptions; |
| 1683 uint32_t vertexAttributeDescriptionCount; |
| 1684 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; |
| 1685 } VkPipelineVertexInputStateCreateInfo; |
| 1686 |
| 1687 typedef struct VkPipelineInputAssemblyStateCreateInfo { |
| 1688 VkStructureType sType; |
| 1689 const void* pNext; |
| 1690 VkPipelineInputAssemblyStateCreateFlags flags; |
| 1691 VkPrimitiveTopology topology; |
| 1692 VkBool32 primitiveRestartEnable; |
| 1693 } VkPipelineInputAssemblyStateCreateInfo; |
| 1694 |
| 1695 typedef struct VkPipelineTessellationStateCreateInfo { |
| 1696 VkStructureType sType; |
| 1697 const void* pNext; |
| 1698 VkPipelineTessellationStateCreateFlags flags; |
| 1699 uint32_t patchControlPoints; |
| 1700 } VkPipelineTessellationStateCreateInfo; |
| 1701 |
| 1702 typedef struct VkViewport { |
| 1703 float x; |
| 1704 float y; |
| 1705 float width; |
| 1706 float height; |
| 1707 float minDepth; |
| 1708 float maxDepth; |
| 1709 } VkViewport; |
| 1710 |
| 1711 typedef struct VkOffset2D { |
| 1712 int32_t x; |
| 1713 int32_t y; |
| 1714 } VkOffset2D; |
| 1715 |
| 1716 typedef struct VkExtent2D { |
| 1717 uint32_t width; |
| 1718 uint32_t height; |
| 1719 } VkExtent2D; |
| 1720 |
| 1721 typedef struct VkRect2D { |
| 1722 VkOffset2D offset; |
| 1723 VkExtent2D extent; |
| 1724 } VkRect2D; |
| 1725 |
| 1726 typedef struct VkPipelineViewportStateCreateInfo { |
| 1727 VkStructureType sType; |
| 1728 const void* pNext; |
| 1729 VkPipelineViewportStateCreateFlags flags; |
| 1730 uint32_t viewportCount; |
| 1731 const VkViewport* pViewports; |
| 1732 uint32_t scissorCount; |
| 1733 const VkRect2D* pScissors; |
| 1734 } VkPipelineViewportStateCreateInfo; |
| 1735 |
| 1736 typedef struct VkPipelineRasterizationStateCreateInfo { |
| 1737 VkStructureType sType; |
| 1738 const void* pNext; |
| 1739 VkPipelineRasterizationStateCreateFlags flags; |
| 1740 VkBool32 depthClampEnable; |
| 1741 VkBool32 rasterizerDiscardEnable; |
| 1742 VkPolygonMode polygonMode; |
| 1743 VkCullModeFlags cullMode; |
| 1744 VkFrontFace frontFace; |
| 1745 VkBool32 depthBiasEnable; |
| 1746 float depthBiasConstantFactor; |
| 1747 float depthBiasClamp; |
| 1748 float depthBiasSlopeFactor; |
| 1749 float lineWidth; |
| 1750 } VkPipelineRasterizationStateCreateInfo; |
| 1751 |
| 1752 typedef struct VkPipelineMultisampleStateCreateInfo { |
| 1753 VkStructureType sType; |
| 1754 const void* pNext; |
| 1755 VkPipelineMultisampleStateCreateFlags flags; |
| 1756 VkSampleCountFlagBits rasterizationSamples; |
| 1757 VkBool32 sampleShadingEnable; |
| 1758 float minSampleShading; |
| 1759 const VkSampleMask* pSampleMask; |
| 1760 VkBool32 alphaToCoverageEnable; |
| 1761 VkBool32 alphaToOneEnable; |
| 1762 } VkPipelineMultisampleStateCreateInfo; |
| 1763 |
| 1764 typedef struct VkStencilOpState { |
| 1765 VkStencilOp failOp; |
| 1766 VkStencilOp passOp; |
| 1767 VkStencilOp depthFailOp; |
| 1768 VkCompareOp compareOp; |
| 1769 uint32_t compareMask; |
| 1770 uint32_t writeMask; |
| 1771 uint32_t reference; |
| 1772 } VkStencilOpState; |
| 1773 |
| 1774 typedef struct VkPipelineDepthStencilStateCreateInfo { |
| 1775 VkStructureType sType; |
| 1776 const void* pNext; |
| 1777 VkPipelineDepthStencilStateCreateFlags flags; |
| 1778 VkBool32 depthTestEnable; |
| 1779 VkBool32 depthWriteEnable; |
| 1780 VkCompareOp depthCompareOp; |
| 1781 VkBool32 depthBoundsTestEnable; |
| 1782 VkBool32 stencilTestEnable; |
| 1783 VkStencilOpState front; |
| 1784 VkStencilOpState back; |
| 1785 float minDepthBounds; |
| 1786 float maxDepthBounds; |
| 1787 } VkPipelineDepthStencilStateCreateInfo; |
| 1788 |
| 1789 typedef struct VkPipelineColorBlendAttachmentState { |
| 1790 VkBool32 blendEnable; |
| 1791 VkBlendFactor srcColorBlendFactor; |
| 1792 VkBlendFactor dstColorBlendFactor; |
| 1793 VkBlendOp colorBlendOp; |
| 1794 VkBlendFactor srcAlphaBlendFactor; |
| 1795 VkBlendFactor dstAlphaBlendFactor; |
| 1796 VkBlendOp alphaBlendOp; |
| 1797 VkColorComponentFlags colorWriteMask; |
| 1798 } VkPipelineColorBlendAttachmentState; |
| 1799 |
| 1800 typedef struct VkPipelineColorBlendStateCreateInfo { |
| 1801 VkStructureType sType; |
| 1802 const void* pNext; |
| 1803 VkPipelineColorBlendStateCreateFlags flags; |
| 1804 VkBool32 logicOpEnable; |
| 1805 VkLogicOp logicOp; |
| 1806 uint32_t attachmentCount; |
| 1807 const VkPipelineColorBlendAttachmentState* pAttachments; |
| 1808 float blendConstants[4]; |
| 1809 } VkPipelineColorBlendStateCreateInfo; |
| 1810 |
| 1811 typedef struct VkPipelineDynamicStateCreateInfo { |
| 1812 VkStructureType sType; |
| 1813 const void* pNext; |
| 1814 VkPipelineDynamicStateCreateFlags flags; |
| 1815 uint32_t dynamicStateCount; |
| 1816 const VkDynamicState* pDynamicStates; |
| 1817 } VkPipelineDynamicStateCreateInfo; |
| 1818 |
| 1819 typedef struct VkGraphicsPipelineCreateInfo { |
| 1820 VkStructureType sType; |
| 1821 const void* pNext; |
| 1822 VkPipelineCreateFlags flags; |
| 1823 uint32_t stageCount; |
| 1824 const VkPipelineShaderStageCreateInfo* pStages; |
| 1825 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; |
| 1826 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; |
| 1827 const VkPipelineTessellationStateCreateInfo* pTessellationState; |
| 1828 const VkPipelineViewportStateCreateInfo* pViewportState; |
| 1829 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; |
| 1830 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; |
| 1831 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; |
| 1832 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; |
| 1833 const VkPipelineDynamicStateCreateInfo* pDynamicState; |
| 1834 VkPipelineLayout layout; |
| 1835 VkRenderPass renderPass; |
| 1836 uint32_t subpass; |
| 1837 VkPipeline basePipelineHandle; |
| 1838 int32_t basePipelineIndex; |
| 1839 } VkGraphicsPipelineCreateInfo; |
| 1840 |
| 1841 typedef struct VkComputePipelineCreateInfo { |
| 1842 VkStructureType sType; |
| 1843 const void* pNext; |
| 1844 VkPipelineCreateFlags flags; |
| 1845 VkPipelineShaderStageCreateInfo stage; |
| 1846 VkPipelineLayout layout; |
| 1847 VkPipeline basePipelineHandle; |
| 1848 int32_t basePipelineIndex; |
| 1849 } VkComputePipelineCreateInfo; |
| 1850 |
| 1851 typedef struct VkPushConstantRange { |
| 1852 VkShaderStageFlags stageFlags; |
| 1853 uint32_t offset; |
| 1854 uint32_t size; |
| 1855 } VkPushConstantRange; |
| 1856 |
| 1857 typedef struct VkPipelineLayoutCreateInfo { |
| 1858 VkStructureType sType; |
| 1859 const void* pNext; |
| 1860 VkPipelineLayoutCreateFlags flags; |
| 1861 uint32_t setLayoutCount; |
| 1862 const VkDescriptorSetLayout* pSetLayouts; |
| 1863 uint32_t pushConstantRangeCount; |
| 1864 const VkPushConstantRange* pPushConstantRanges; |
| 1865 } VkPipelineLayoutCreateInfo; |
| 1866 |
| 1867 typedef struct VkSamplerCreateInfo { |
| 1868 VkStructureType sType; |
| 1869 const void* pNext; |
| 1870 VkSamplerCreateFlags flags; |
| 1871 VkFilter magFilter; |
| 1872 VkFilter minFilter; |
| 1873 VkSamplerMipmapMode mipmapMode; |
| 1874 VkSamplerAddressMode addressModeU; |
| 1875 VkSamplerAddressMode addressModeV; |
| 1876 VkSamplerAddressMode addressModeW; |
| 1877 float mipLodBias; |
| 1878 VkBool32 anisotropyEnable; |
| 1879 float maxAnisotropy; |
| 1880 VkBool32 compareEnable; |
| 1881 VkCompareOp compareOp; |
| 1882 float minLod; |
| 1883 float maxLod; |
| 1884 VkBorderColor borderColor; |
| 1885 VkBool32 unnormalizedCoordinates; |
| 1886 } VkSamplerCreateInfo; |
| 1887 |
| 1888 typedef struct VkDescriptorSetLayoutBinding { |
| 1889 uint32_t binding; |
| 1890 VkDescriptorType descriptorType; |
| 1891 uint32_t descriptorCount; |
| 1892 VkShaderStageFlags stageFlags; |
| 1893 const VkSampler* pImmutableSamplers; |
| 1894 } VkDescriptorSetLayoutBinding; |
| 1895 |
| 1896 typedef struct VkDescriptorSetLayoutCreateInfo { |
| 1897 VkStructureType sType; |
| 1898 const void* pNext; |
| 1899 VkDescriptorSetLayoutCreateFlags flags; |
| 1900 uint32_t bindingCount; |
| 1901 const VkDescriptorSetLayoutBinding* pBindings; |
| 1902 } VkDescriptorSetLayoutCreateInfo; |
| 1903 |
| 1904 typedef struct VkDescriptorPoolSize { |
| 1905 VkDescriptorType type; |
| 1906 uint32_t descriptorCount; |
| 1907 } VkDescriptorPoolSize; |
| 1908 |
| 1909 typedef struct VkDescriptorPoolCreateInfo { |
| 1910 VkStructureType sType; |
| 1911 const void* pNext; |
| 1912 VkDescriptorPoolCreateFlags flags; |
| 1913 uint32_t maxSets; |
| 1914 uint32_t poolSizeCount; |
| 1915 const VkDescriptorPoolSize* pPoolSizes; |
| 1916 } VkDescriptorPoolCreateInfo; |
| 1917 |
| 1918 typedef struct VkDescriptorSetAllocateInfo { |
| 1919 VkStructureType sType; |
| 1920 const void* pNext; |
| 1921 VkDescriptorPool descriptorPool; |
| 1922 uint32_t descriptorSetCount; |
| 1923 const VkDescriptorSetLayout* pSetLayouts; |
| 1924 } VkDescriptorSetAllocateInfo; |
| 1925 |
| 1926 typedef struct VkDescriptorImageInfo { |
| 1927 VkSampler sampler; |
| 1928 VkImageView imageView; |
| 1929 VkImageLayout imageLayout; |
| 1930 } VkDescriptorImageInfo; |
| 1931 |
| 1932 typedef struct VkDescriptorBufferInfo { |
| 1933 VkBuffer buffer; |
| 1934 VkDeviceSize offset; |
| 1935 VkDeviceSize range; |
| 1936 } VkDescriptorBufferInfo; |
| 1937 |
| 1938 typedef struct VkWriteDescriptorSet { |
| 1939 VkStructureType sType; |
| 1940 const void* pNext; |
| 1941 VkDescriptorSet dstSet; |
| 1942 uint32_t dstBinding; |
| 1943 uint32_t dstArrayElement; |
| 1944 uint32_t descriptorCount; |
| 1945 VkDescriptorType descriptorType; |
| 1946 const VkDescriptorImageInfo* pImageInfo; |
| 1947 const VkDescriptorBufferInfo* pBufferInfo; |
| 1948 const VkBufferView* pTexelBufferView; |
| 1949 } VkWriteDescriptorSet; |
| 1950 |
| 1951 typedef struct VkCopyDescriptorSet { |
| 1952 VkStructureType sType; |
| 1953 const void* pNext; |
| 1954 VkDescriptorSet srcSet; |
| 1955 uint32_t srcBinding; |
| 1956 uint32_t srcArrayElement; |
| 1957 VkDescriptorSet dstSet; |
| 1958 uint32_t dstBinding; |
| 1959 uint32_t dstArrayElement; |
| 1960 uint32_t descriptorCount; |
| 1961 } VkCopyDescriptorSet; |
| 1962 |
| 1963 typedef struct VkFramebufferCreateInfo { |
| 1964 VkStructureType sType; |
| 1965 const void* pNext; |
| 1966 VkFramebufferCreateFlags flags; |
| 1967 VkRenderPass renderPass; |
| 1968 uint32_t attachmentCount; |
| 1969 const VkImageView* pAttachments; |
| 1970 uint32_t width; |
| 1971 uint32_t height; |
| 1972 uint32_t layers; |
| 1973 } VkFramebufferCreateInfo; |
| 1974 |
| 1975 typedef struct VkAttachmentDescription { |
| 1976 VkAttachmentDescriptionFlags flags; |
| 1977 VkFormat format; |
| 1978 VkSampleCountFlagBits samples; |
| 1979 VkAttachmentLoadOp loadOp; |
| 1980 VkAttachmentStoreOp storeOp; |
| 1981 VkAttachmentLoadOp stencilLoadOp; |
| 1982 VkAttachmentStoreOp stencilStoreOp; |
| 1983 VkImageLayout initialLayout; |
| 1984 VkImageLayout finalLayout; |
| 1985 } VkAttachmentDescription; |
| 1986 |
| 1987 typedef struct VkAttachmentReference { |
| 1988 uint32_t attachment; |
| 1989 VkImageLayout layout; |
| 1990 } VkAttachmentReference; |
| 1991 |
| 1992 typedef struct VkSubpassDescription { |
| 1993 VkSubpassDescriptionFlags flags; |
| 1994 VkPipelineBindPoint pipelineBindPoint; |
| 1995 uint32_t inputAttachmentCount; |
| 1996 const VkAttachmentReference* pInputAttachments; |
| 1997 uint32_t colorAttachmentCount; |
| 1998 const VkAttachmentReference* pColorAttachments; |
| 1999 const VkAttachmentReference* pResolveAttachments; |
| 2000 const VkAttachmentReference* pDepthStencilAttachment; |
| 2001 uint32_t preserveAttachmentCount; |
| 2002 const uint32_t* pPreserveAttachments; |
| 2003 } VkSubpassDescription; |
| 2004 |
| 2005 typedef struct VkSubpassDependency { |
| 2006 uint32_t srcSubpass; |
| 2007 uint32_t dstSubpass; |
| 2008 VkPipelineStageFlags srcStageMask; |
| 2009 VkPipelineStageFlags dstStageMask; |
| 2010 VkAccessFlags srcAccessMask; |
| 2011 VkAccessFlags dstAccessMask; |
| 2012 VkDependencyFlags dependencyFlags; |
| 2013 } VkSubpassDependency; |
| 2014 |
| 2015 typedef struct VkRenderPassCreateInfo { |
| 2016 VkStructureType sType; |
| 2017 const void* pNext; |
| 2018 VkRenderPassCreateFlags flags; |
| 2019 uint32_t attachmentCount; |
| 2020 const VkAttachmentDescription* pAttachments; |
| 2021 uint32_t subpassCount; |
| 2022 const VkSubpassDescription* pSubpasses; |
| 2023 uint32_t dependencyCount; |
| 2024 const VkSubpassDependency* pDependencies; |
| 2025 } VkRenderPassCreateInfo; |
| 2026 |
| 2027 typedef struct VkCommandPoolCreateInfo { |
| 2028 VkStructureType sType; |
| 2029 const void* pNext; |
| 2030 VkCommandPoolCreateFlags flags; |
| 2031 uint32_t queueFamilyIndex; |
| 2032 } VkCommandPoolCreateInfo; |
| 2033 |
| 2034 typedef struct VkCommandBufferAllocateInfo { |
| 2035 VkStructureType sType; |
| 2036 const void* pNext; |
| 2037 VkCommandPool commandPool; |
| 2038 VkCommandBufferLevel level; |
| 2039 uint32_t commandBufferCount; |
| 2040 } VkCommandBufferAllocateInfo; |
| 2041 |
| 2042 typedef struct VkCommandBufferInheritanceInfo { |
| 2043 VkStructureType sType; |
| 2044 const void* pNext; |
| 2045 VkRenderPass renderPass; |
| 2046 uint32_t subpass; |
| 2047 VkFramebuffer framebuffer; |
| 2048 VkBool32 occlusionQueryEnable; |
| 2049 VkQueryControlFlags queryFlags; |
| 2050 VkQueryPipelineStatisticFlags pipelineStatistics; |
| 2051 } VkCommandBufferInheritanceInfo; |
| 2052 |
| 2053 typedef struct VkCommandBufferBeginInfo { |
| 2054 VkStructureType sType; |
| 2055 const void* pNext; |
| 2056 VkCommandBufferUsageFlags flags; |
| 2057 const VkCommandBufferInheritanceInfo* pInheritanceInfo; |
| 2058 } VkCommandBufferBeginInfo; |
| 2059 |
| 2060 typedef struct VkBufferCopy { |
| 2061 VkDeviceSize srcOffset; |
| 2062 VkDeviceSize dstOffset; |
| 2063 VkDeviceSize size; |
| 2064 } VkBufferCopy; |
| 2065 |
| 2066 typedef struct VkImageSubresourceLayers { |
| 2067 VkImageAspectFlags aspectMask; |
| 2068 uint32_t mipLevel; |
| 2069 uint32_t baseArrayLayer; |
| 2070 uint32_t layerCount; |
| 2071 } VkImageSubresourceLayers; |
| 2072 |
| 2073 typedef struct VkImageCopy { |
| 2074 VkImageSubresourceLayers srcSubresource; |
| 2075 VkOffset3D srcOffset; |
| 2076 VkImageSubresourceLayers dstSubresource; |
| 2077 VkOffset3D dstOffset; |
| 2078 VkExtent3D extent; |
| 2079 } VkImageCopy; |
| 2080 |
| 2081 typedef struct VkImageBlit { |
| 2082 VkImageSubresourceLayers srcSubresource; |
| 2083 VkOffset3D srcOffsets[2]; |
| 2084 VkImageSubresourceLayers dstSubresource; |
| 2085 VkOffset3D dstOffsets[2]; |
| 2086 } VkImageBlit; |
| 2087 |
| 2088 typedef struct VkBufferImageCopy { |
| 2089 VkDeviceSize bufferOffset; |
| 2090 uint32_t bufferRowLength; |
| 2091 uint32_t bufferImageHeight; |
| 2092 VkImageSubresourceLayers imageSubresource; |
| 2093 VkOffset3D imageOffset; |
| 2094 VkExtent3D imageExtent; |
| 2095 } VkBufferImageCopy; |
| 2096 |
| 2097 typedef union VkClearColorValue { |
| 2098 float float32[4]; |
| 2099 int32_t int32[4]; |
| 2100 uint32_t uint32[4]; |
| 2101 } VkClearColorValue; |
| 2102 |
| 2103 typedef struct VkClearDepthStencilValue { |
| 2104 float depth; |
| 2105 uint32_t stencil; |
| 2106 } VkClearDepthStencilValue; |
| 2107 |
| 2108 typedef union VkClearValue { |
| 2109 VkClearColorValue color; |
| 2110 VkClearDepthStencilValue depthStencil; |
| 2111 } VkClearValue; |
| 2112 |
| 2113 typedef struct VkClearAttachment { |
| 2114 VkImageAspectFlags aspectMask; |
| 2115 uint32_t colorAttachment; |
| 2116 VkClearValue clearValue; |
| 2117 } VkClearAttachment; |
| 2118 |
| 2119 typedef struct VkClearRect { |
| 2120 VkRect2D rect; |
| 2121 uint32_t baseArrayLayer; |
| 2122 uint32_t layerCount; |
| 2123 } VkClearRect; |
| 2124 |
| 2125 typedef struct VkImageResolve { |
| 2126 VkImageSubresourceLayers srcSubresource; |
| 2127 VkOffset3D srcOffset; |
| 2128 VkImageSubresourceLayers dstSubresource; |
| 2129 VkOffset3D dstOffset; |
| 2130 VkExtent3D extent; |
| 2131 } VkImageResolve; |
| 2132 |
| 2133 typedef struct VkMemoryBarrier { |
| 2134 VkStructureType sType; |
| 2135 const void* pNext; |
| 2136 VkAccessFlags srcAccessMask; |
| 2137 VkAccessFlags dstAccessMask; |
| 2138 } VkMemoryBarrier; |
| 2139 |
| 2140 typedef struct VkBufferMemoryBarrier { |
| 2141 VkStructureType sType; |
| 2142 const void* pNext; |
| 2143 VkAccessFlags srcAccessMask; |
| 2144 VkAccessFlags dstAccessMask; |
| 2145 uint32_t srcQueueFamilyIndex; |
| 2146 uint32_t dstQueueFamilyIndex; |
| 2147 VkBuffer buffer; |
| 2148 VkDeviceSize offset; |
| 2149 VkDeviceSize size; |
| 2150 } VkBufferMemoryBarrier; |
| 2151 |
| 2152 typedef struct VkImageMemoryBarrier { |
| 2153 VkStructureType sType; |
| 2154 const void* pNext; |
| 2155 VkAccessFlags srcAccessMask; |
| 2156 VkAccessFlags dstAccessMask; |
| 2157 VkImageLayout oldLayout; |
| 2158 VkImageLayout newLayout; |
| 2159 uint32_t srcQueueFamilyIndex; |
| 2160 uint32_t dstQueueFamilyIndex; |
| 2161 VkImage image; |
| 2162 VkImageSubresourceRange subresourceRange; |
| 2163 } VkImageMemoryBarrier; |
| 2164 |
| 2165 typedef struct VkRenderPassBeginInfo { |
| 2166 VkStructureType sType; |
| 2167 const void* pNext; |
| 2168 VkRenderPass renderPass; |
| 2169 VkFramebuffer framebuffer; |
| 2170 VkRect2D renderArea; |
| 2171 uint32_t clearValueCount; |
| 2172 const VkClearValue* pClearValues; |
| 2173 } VkRenderPassBeginInfo; |
| 2174 |
| 2175 typedef struct VkDispatchIndirectCommand { |
| 2176 uint32_t x; |
| 2177 uint32_t y; |
| 2178 uint32_t z; |
| 2179 } VkDispatchIndirectCommand; |
| 2180 |
| 2181 typedef struct VkDrawIndexedIndirectCommand { |
| 2182 uint32_t indexCount; |
| 2183 uint32_t instanceCount; |
| 2184 uint32_t firstIndex; |
| 2185 int32_t vertexOffset; |
| 2186 uint32_t firstInstance; |
| 2187 } VkDrawIndexedIndirectCommand; |
| 2188 |
| 2189 typedef struct VkDrawIndirectCommand { |
| 2190 uint32_t vertexCount; |
| 2191 uint32_t instanceCount; |
| 2192 uint32_t firstVertex; |
| 2193 uint32_t firstInstance; |
| 2194 } VkDrawIndirectCommand; |
| 2195 |
| 2196 |
| 2197 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* p
CreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); |
| 2198 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAll
ocationCallbacks* pAllocator); |
| 2199 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance
, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); |
| 2200 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physi
calDevice, VkPhysicalDeviceFeatures* pFeatures); |
| 2201 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevi
ce physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); |
| 2202 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhy
sicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling til
ing, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties*
pImageFormatProperties); |
| 2203 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice phy
sicalDevice, VkPhysicalDeviceProperties* pProperties); |
| 2204 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysica
lDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProper
ties* pQueueFamilyProperties); |
| 2205 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevi
ce physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); |
| 2206 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance ins
tance, const char* pName); |
| 2207 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device,
const char* pName); |
| 2208 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice
, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkDevice* pDevice); |
| 2209 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocatio
nCallbacks* pAllocator); |
| 2210 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const c
har* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); |
| 2211 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysica
lDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExte
nsionProperties* pProperties); |
| 2212 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* p
PropertyCount, VkLayerProperties* pProperties); |
| 2213 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDev
ice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); |
| 2214 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFa
milyIndex, uint32_t queueIndex, VkQueue* pQueue); |
| 2215 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCo
unt, const VkSubmitInfo* pSubmits, VkFence fence); |
| 2216 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); |
| 2217 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); |
| 2218 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemo
ryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDevice
Memory* pMemory); |
| 2219 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memor
y, const VkAllocationCallbacks* pAllocator); |
| 2220 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory me
mory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppD
ata); |
| 2221 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memo
ry); |
| 2222 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uin
t32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); |
| 2223 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device
, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); |
| 2224 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDev
iceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); |
| 2225 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer b
uffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); |
| 2226 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage ima
ge, VkDeviceMemory memory, VkDeviceSize memoryOffset); |
| 2227 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkB
uffer buffer, VkMemoryRequirements* pMemoryRequirements); |
| 2228 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkIm
age image, VkMemoryRequirements* pMemoryRequirements); |
| 2229 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device
, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryReq
uirements* pSparseMemoryRequirements); |
| 2230 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkP
hysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFl
agBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pProper
tyCount, VkSparseImageFormatProperties* pProperties); |
| 2231 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bind
InfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); |
| 2232 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
; |
| 2233 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, con
st VkAllocationCallbacks* pAllocator); |
| 2234 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceC
ount, const VkFence* pFences); |
| 2235 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fenc
e); |
| 2236 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenc
eCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); |
| 2237 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSem
aphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaph
ore* pSemaphore); |
| 2238 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore se
maphore, const VkAllocationCallbacks* pAllocator); |
| 2239 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
; |
| 2240 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, con
st VkAllocationCallbacks* pAllocator); |
| 2241 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent even
t); |
| 2242 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); |
| 2243 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); |
| 2244 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQue
ryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryP
ool* pQueryPool); |
| 2245 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool qu
eryPool, const VkAllocationCallbacks* pAllocator); |
| 2246 typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQuery
Pool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void*
pData, VkDeviceSize stride, VkQueryResultFlags flags); |
| 2247 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBuffer
CreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuf
fer); |
| 2248 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer,
const VkAllocationCallbacks* pAllocator); |
| 2249 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBu
fferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuff
erView* pView); |
| 2250 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView
bufferView, const VkAllocationCallbacks* pAllocator); |
| 2251 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
; |
| 2252 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, con
st VkAllocationCallbacks* pAllocator); |
| 2253 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkIma
ge image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); |
| 2254 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkIma
geViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageV
iew* pView); |
| 2255 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView im
ageView, const VkAllocationCallbacks* pAllocator); |
| 2256 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const Vk
ShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, Vk
ShaderModule* pShaderModule); |
| 2257 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderMod
ule shaderModule, const VkAllocationCallbacks* pAllocator); |
| 2258 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const V
kPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache); |
| 2259 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipeline
Cache pipelineCache, const VkAllocationCallbacks* pAllocator); |
| 2260 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipe
lineCache pipelineCache, size_t* pDataSize, void* pData); |
| 2261 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipel
ineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); |
| 2262 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkP
ipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCr
eateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPi
pelines); |
| 2263 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPi
pelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCrea
teInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipe
lines); |
| 2264 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipe
line, const VkAllocationCallbacks* pAllocator); |
| 2265 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const
VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkPipelineLayout* pPipelineLayout); |
| 2266 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelin
eLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); |
| 2267 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSampl
erCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* p
Sampler); |
| 2268 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sample
r, const VkAllocationCallbacks* pAllocator); |
| 2269 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, c
onst VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkDescriptorSetLayout* pSetLayout); |
| 2270 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDe
scriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); |
| 2271 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const
VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkDescriptorPool* pDescriptorPool); |
| 2272 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescrip
torPool descriptorPool, const VkAllocationCallbacks* pAllocator); |
| 2273 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescr
iptorPool descriptorPool, VkDescriptorPoolResetFlags flags); |
| 2274 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, cons
t VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); |
| 2275 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescri
ptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDe
scriptorSets); |
| 2276 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t d
escriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t des
criptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); |
| 2277 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkF
ramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFr
amebuffer* pFramebuffer); |
| 2278 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffe
r framebuffer, const VkAllocationCallbacks* pAllocator); |
| 2279 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRe
nderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRend
erPass* pRenderPass); |
| 2280 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass
renderPass, const VkAllocationCallbacks* pAllocator); |
| 2281 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRend
erPass renderPass, VkExtent2D* pGranularity); |
| 2282 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkC
ommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCo
mmandPool* pCommandPool); |
| 2283 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPoo
l commandPool, const VkAllocationCallbacks* pAllocator); |
| 2284 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandP
ool commandPool, VkCommandPoolResetFlags flags); |
| 2285 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, cons
t VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); |
| 2286 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPoo
l commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffe
rs); |
| 2287 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBu
ffer, const VkCommandBufferBeginInfo* pBeginInfo); |
| 2288 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuff
er); |
| 2289 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBu
ffer, VkCommandBufferResetFlags flags); |
| 2290 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, V
kPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); |
| 2291 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, ui
nt32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); |
| 2292 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uin
t32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); |
| 2293 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, f
loat lineWidth); |
| 2294 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, f
loat depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); |
| 2295 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuff
er, const float blendConstants[4]); |
| 2296 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer,
float minDepthBounds, float maxDepthBounds); |
| 2297 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer command
Buffer, VkStencilFaceFlags faceMask, uint32_t compareMask); |
| 2298 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBu
ffer, VkStencilFaceFlags faceMask, uint32_t writeMask); |
| 2299 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBu
ffer, VkStencilFaceFlags faceMask, uint32_t reference); |
| 2300 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuf
fer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t fi
rstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uin
t32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); |
| 2301 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer
, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); |
| 2302 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuff
er, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, cons
t VkDeviceSize* pOffsets); |
| 2303 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t
vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstanc
e); |
| 2304 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, ui
nt32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOf
fset, uint32_t firstInstance); |
| 2305 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, V
kBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); |
| 2306 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBu
ffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
; |
| 2307 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint3
2_t x, uint32_t y, uint32_t z); |
| 2308 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffe
r, VkBuffer buffer, VkDeviceSize offset); |
| 2309 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkB
uffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* p
Regions); |
| 2310 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkIm
age srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstI
mageLayout, uint32_t regionCount, const VkImageCopy* pRegions); |
| 2311 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkIm
age srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstI
mageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); |
| 2312 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuff
er, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t
regionCount, const VkBufferImageCopy* pRegions); |
| 2313 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuff
er, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t
regionCount, const VkBufferImageCopy* pRegions); |
| 2314 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, V
kBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t
* pData); |
| 2315 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkB
uffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); |
| 2316 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer
, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uin
t32_t rangeCount, const VkImageSubresourceRange* pRanges); |
| 2317 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer comman
dBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValu
e* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); |
| 2318 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffe
r, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rec
tCount, const VkClearRect* pRects); |
| 2319 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, V
kImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout d
stImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); |
| 2320 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEve
nt event, VkPipelineStageFlags stageMask); |
| 2321 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkE
vent event, VkPipelineStageFlags stageMask); |
| 2322 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uin
t32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkP
ipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarri
er* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarr
ier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemor
yBarrier* pImageMemoryBarriers); |
| 2323 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer
, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDepend
encyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* p
MemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier*
pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarr
ier* pImageMemoryBarriers); |
| 2324 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQ
ueryPool queryPool, uint32_t query, VkQueryControlFlags flags); |
| 2325 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQue
ryPool queryPool, uint32_t query); |
| 2326 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer,
VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); |
| 2327 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); |
| 2328 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandB
uffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer
dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flag
s); |
| 2329 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer,
VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_
t size, const void* pValues); |
| 2330 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer
, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); |
| 2331 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, Vk
SubpassContents contents); |
| 2332 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); |
| 2333 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer
, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); |
| 2334 |
| 2335 #ifndef VK_NO_PROTOTYPES |
| 2336 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( |
| 2337 const VkInstanceCreateInfo* pCreateInfo, |
| 2338 const VkAllocationCallbacks* pAllocator, |
| 2339 VkInstance* pInstance); |
| 2340 |
| 2341 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( |
| 2342 VkInstance instance, |
| 2343 const VkAllocationCallbacks* pAllocator); |
| 2344 |
| 2345 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( |
| 2346 VkInstance instance, |
| 2347 uint32_t* pPhysicalDeviceCount, |
| 2348 VkPhysicalDevice* pPhysicalDevices); |
| 2349 |
| 2350 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( |
| 2351 VkPhysicalDevice physicalDevice, |
| 2352 VkPhysicalDeviceFeatures* pFeatures); |
| 2353 |
| 2354 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( |
| 2355 VkPhysicalDevice physicalDevice, |
| 2356 VkFormat format, |
| 2357 VkFormatProperties* pFormatProperties); |
| 2358 |
| 2359 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( |
| 2360 VkPhysicalDevice physicalDevice, |
| 2361 VkFormat format, |
| 2362 VkImageType type, |
| 2363 VkImageTiling tiling, |
| 2364 VkImageUsageFlags usage, |
| 2365 VkImageCreateFlags flags, |
| 2366 VkImageFormatProperties* pImageFormatProperties); |
| 2367 |
| 2368 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( |
| 2369 VkPhysicalDevice physicalDevice, |
| 2370 VkPhysicalDeviceProperties* pProperties); |
| 2371 |
| 2372 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( |
| 2373 VkPhysicalDevice physicalDevice, |
| 2374 uint32_t* pQueueFamilyPropertyCount, |
| 2375 VkQueueFamilyProperties* pQueueFamilyProperties); |
| 2376 |
| 2377 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( |
| 2378 VkPhysicalDevice physicalDevice, |
| 2379 VkPhysicalDeviceMemoryProperties* pMemoryProperties); |
| 2380 |
| 2381 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( |
| 2382 VkInstance instance, |
| 2383 const char* pName); |
| 2384 |
| 2385 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( |
| 2386 VkDevice device, |
| 2387 const char* pName); |
| 2388 |
| 2389 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( |
| 2390 VkPhysicalDevice physicalDevice, |
| 2391 const VkDeviceCreateInfo* pCreateInfo, |
| 2392 const VkAllocationCallbacks* pAllocator, |
| 2393 VkDevice* pDevice); |
| 2394 |
| 2395 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( |
| 2396 VkDevice device, |
| 2397 const VkAllocationCallbacks* pAllocator); |
| 2398 |
| 2399 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( |
| 2400 const char* pLayerName, |
| 2401 uint32_t* pPropertyCount, |
| 2402 VkExtensionProperties* pProperties); |
| 2403 |
| 2404 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( |
| 2405 VkPhysicalDevice physicalDevice, |
| 2406 const char* pLayerName, |
| 2407 uint32_t* pPropertyCount, |
| 2408 VkExtensionProperties* pProperties); |
| 2409 |
| 2410 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( |
| 2411 uint32_t* pPropertyCount, |
| 2412 VkLayerProperties* pProperties); |
| 2413 |
| 2414 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( |
| 2415 VkPhysicalDevice physicalDevice, |
| 2416 uint32_t* pPropertyCount, |
| 2417 VkLayerProperties* pProperties); |
| 2418 |
| 2419 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( |
| 2420 VkDevice device, |
| 2421 uint32_t queueFamilyIndex, |
| 2422 uint32_t queueIndex, |
| 2423 VkQueue* pQueue); |
| 2424 |
| 2425 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( |
| 2426 VkQueue queue, |
| 2427 uint32_t submitCount, |
| 2428 const VkSubmitInfo* pSubmits, |
| 2429 VkFence fence); |
| 2430 |
| 2431 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( |
| 2432 VkQueue queue); |
| 2433 |
| 2434 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( |
| 2435 VkDevice device); |
| 2436 |
| 2437 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( |
| 2438 VkDevice device, |
| 2439 const VkMemoryAllocateInfo* pAllocateInfo, |
| 2440 const VkAllocationCallbacks* pAllocator, |
| 2441 VkDeviceMemory* pMemory); |
| 2442 |
| 2443 VKAPI_ATTR void VKAPI_CALL vkFreeMemory( |
| 2444 VkDevice device, |
| 2445 VkDeviceMemory memory, |
| 2446 const VkAllocationCallbacks* pAllocator); |
| 2447 |
| 2448 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( |
| 2449 VkDevice device, |
| 2450 VkDeviceMemory memory, |
| 2451 VkDeviceSize offset, |
| 2452 VkDeviceSize size, |
| 2453 VkMemoryMapFlags flags, |
| 2454 void** ppData); |
| 2455 |
| 2456 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( |
| 2457 VkDevice device, |
| 2458 VkDeviceMemory memory); |
| 2459 |
| 2460 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( |
| 2461 VkDevice device, |
| 2462 uint32_t memoryRangeCount, |
| 2463 const VkMappedMemoryRange* pMemoryRanges); |
| 2464 |
| 2465 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( |
| 2466 VkDevice device, |
| 2467 uint32_t memoryRangeCount, |
| 2468 const VkMappedMemoryRange* pMemoryRanges); |
| 2469 |
| 2470 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( |
| 2471 VkDevice device, |
| 2472 VkDeviceMemory memory, |
| 2473 VkDeviceSize* pCommittedMemoryInBytes); |
| 2474 |
| 2475 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( |
| 2476 VkDevice device, |
| 2477 VkBuffer buffer, |
| 2478 VkDeviceMemory memory, |
| 2479 VkDeviceSize memoryOffset); |
| 2480 |
| 2481 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( |
| 2482 VkDevice device, |
| 2483 VkImage image, |
| 2484 VkDeviceMemory memory, |
| 2485 VkDeviceSize memoryOffset); |
| 2486 |
| 2487 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( |
| 2488 VkDevice device, |
| 2489 VkBuffer buffer, |
| 2490 VkMemoryRequirements* pMemoryRequirements); |
| 2491 |
| 2492 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( |
| 2493 VkDevice device, |
| 2494 VkImage image, |
| 2495 VkMemoryRequirements* pMemoryRequirements); |
| 2496 |
| 2497 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( |
| 2498 VkDevice device, |
| 2499 VkImage image, |
| 2500 uint32_t* pSparseMemoryRequirementCount, |
| 2501 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); |
| 2502 |
| 2503 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( |
| 2504 VkPhysicalDevice physicalDevice, |
| 2505 VkFormat format, |
| 2506 VkImageType type, |
| 2507 VkSampleCountFlagBits samples, |
| 2508 VkImageUsageFlags usage, |
| 2509 VkImageTiling tiling, |
| 2510 uint32_t* pPropertyCount, |
| 2511 VkSparseImageFormatProperties* pProperties); |
| 2512 |
| 2513 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( |
| 2514 VkQueue queue, |
| 2515 uint32_t bindInfoCount, |
| 2516 const VkBindSparseInfo* pBindInfo, |
| 2517 VkFence fence); |
| 2518 |
| 2519 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( |
| 2520 VkDevice device, |
| 2521 const VkFenceCreateInfo* pCreateInfo, |
| 2522 const VkAllocationCallbacks* pAllocator, |
| 2523 VkFence* pFence); |
| 2524 |
| 2525 VKAPI_ATTR void VKAPI_CALL vkDestroyFence( |
| 2526 VkDevice device, |
| 2527 VkFence fence, |
| 2528 const VkAllocationCallbacks* pAllocator); |
| 2529 |
| 2530 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( |
| 2531 VkDevice device, |
| 2532 uint32_t fenceCount, |
| 2533 const VkFence* pFences); |
| 2534 |
| 2535 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( |
| 2536 VkDevice device, |
| 2537 VkFence fence); |
| 2538 |
| 2539 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( |
| 2540 VkDevice device, |
| 2541 uint32_t fenceCount, |
| 2542 const VkFence* pFences, |
| 2543 VkBool32 waitAll, |
| 2544 uint64_t timeout); |
| 2545 |
| 2546 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( |
| 2547 VkDevice device, |
| 2548 const VkSemaphoreCreateInfo* pCreateInfo, |
| 2549 const VkAllocationCallbacks* pAllocator, |
| 2550 VkSemaphore* pSemaphore); |
| 2551 |
| 2552 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( |
| 2553 VkDevice device, |
| 2554 VkSemaphore semaphore, |
| 2555 const VkAllocationCallbacks* pAllocator); |
| 2556 |
| 2557 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( |
| 2558 VkDevice device, |
| 2559 const VkEventCreateInfo* pCreateInfo, |
| 2560 const VkAllocationCallbacks* pAllocator, |
| 2561 VkEvent* pEvent); |
| 2562 |
| 2563 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( |
| 2564 VkDevice device, |
| 2565 VkEvent event, |
| 2566 const VkAllocationCallbacks* pAllocator); |
| 2567 |
| 2568 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( |
| 2569 VkDevice device, |
| 2570 VkEvent event); |
| 2571 |
| 2572 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( |
| 2573 VkDevice device, |
| 2574 VkEvent event); |
| 2575 |
| 2576 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( |
| 2577 VkDevice device, |
| 2578 VkEvent event); |
| 2579 |
| 2580 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( |
| 2581 VkDevice device, |
| 2582 const VkQueryPoolCreateInfo* pCreateInfo, |
| 2583 const VkAllocationCallbacks* pAllocator, |
| 2584 VkQueryPool* pQueryPool); |
| 2585 |
| 2586 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( |
| 2587 VkDevice device, |
| 2588 VkQueryPool queryPool, |
| 2589 const VkAllocationCallbacks* pAllocator); |
| 2590 |
| 2591 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( |
| 2592 VkDevice device, |
| 2593 VkQueryPool queryPool, |
| 2594 uint32_t firstQuery, |
| 2595 uint32_t queryCount, |
| 2596 size_t dataSize, |
| 2597 void* pData, |
| 2598 VkDeviceSize stride, |
| 2599 VkQueryResultFlags flags); |
| 2600 |
| 2601 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( |
| 2602 VkDevice device, |
| 2603 const VkBufferCreateInfo* pCreateInfo, |
| 2604 const VkAllocationCallbacks* pAllocator, |
| 2605 VkBuffer* pBuffer); |
| 2606 |
| 2607 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( |
| 2608 VkDevice device, |
| 2609 VkBuffer buffer, |
| 2610 const VkAllocationCallbacks* pAllocator); |
| 2611 |
| 2612 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( |
| 2613 VkDevice device, |
| 2614 const VkBufferViewCreateInfo* pCreateInfo, |
| 2615 const VkAllocationCallbacks* pAllocator, |
| 2616 VkBufferView* pView); |
| 2617 |
| 2618 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( |
| 2619 VkDevice device, |
| 2620 VkBufferView bufferView, |
| 2621 const VkAllocationCallbacks* pAllocator); |
| 2622 |
| 2623 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( |
| 2624 VkDevice device, |
| 2625 const VkImageCreateInfo* pCreateInfo, |
| 2626 const VkAllocationCallbacks* pAllocator, |
| 2627 VkImage* pImage); |
| 2628 |
| 2629 VKAPI_ATTR void VKAPI_CALL vkDestroyImage( |
| 2630 VkDevice device, |
| 2631 VkImage image, |
| 2632 const VkAllocationCallbacks* pAllocator); |
| 2633 |
| 2634 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( |
| 2635 VkDevice device, |
| 2636 VkImage image, |
| 2637 const VkImageSubresource* pSubresource, |
| 2638 VkSubresourceLayout* pLayout); |
| 2639 |
| 2640 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( |
| 2641 VkDevice device, |
| 2642 const VkImageViewCreateInfo* pCreateInfo, |
| 2643 const VkAllocationCallbacks* pAllocator, |
| 2644 VkImageView* pView); |
| 2645 |
| 2646 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( |
| 2647 VkDevice device, |
| 2648 VkImageView imageView, |
| 2649 const VkAllocationCallbacks* pAllocator); |
| 2650 |
| 2651 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( |
| 2652 VkDevice device, |
| 2653 const VkShaderModuleCreateInfo* pCreateInfo, |
| 2654 const VkAllocationCallbacks* pAllocator, |
| 2655 VkShaderModule* pShaderModule); |
| 2656 |
| 2657 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( |
| 2658 VkDevice device, |
| 2659 VkShaderModule shaderModule, |
| 2660 const VkAllocationCallbacks* pAllocator); |
| 2661 |
| 2662 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( |
| 2663 VkDevice device, |
| 2664 const VkPipelineCacheCreateInfo* pCreateInfo, |
| 2665 const VkAllocationCallbacks* pAllocator, |
| 2666 VkPipelineCache* pPipelineCache); |
| 2667 |
| 2668 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( |
| 2669 VkDevice device, |
| 2670 VkPipelineCache pipelineCache, |
| 2671 const VkAllocationCallbacks* pAllocator); |
| 2672 |
| 2673 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( |
| 2674 VkDevice device, |
| 2675 VkPipelineCache pipelineCache, |
| 2676 size_t* pDataSize, |
| 2677 void* pData); |
| 2678 |
| 2679 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( |
| 2680 VkDevice device, |
| 2681 VkPipelineCache dstCache, |
| 2682 uint32_t srcCacheCount, |
| 2683 const VkPipelineCache* pSrcCaches); |
| 2684 |
| 2685 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( |
| 2686 VkDevice device, |
| 2687 VkPipelineCache pipelineCache, |
| 2688 uint32_t createInfoCount, |
| 2689 const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| 2690 const VkAllocationCallbacks* pAllocator, |
| 2691 VkPipeline* pPipelines); |
| 2692 |
| 2693 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( |
| 2694 VkDevice device, |
| 2695 VkPipelineCache pipelineCache, |
| 2696 uint32_t createInfoCount, |
| 2697 const VkComputePipelineCreateInfo* pCreateInfos, |
| 2698 const VkAllocationCallbacks* pAllocator, |
| 2699 VkPipeline* pPipelines); |
| 2700 |
| 2701 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( |
| 2702 VkDevice device, |
| 2703 VkPipeline pipeline, |
| 2704 const VkAllocationCallbacks* pAllocator); |
| 2705 |
| 2706 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( |
| 2707 VkDevice device, |
| 2708 const VkPipelineLayoutCreateInfo* pCreateInfo, |
| 2709 const VkAllocationCallbacks* pAllocator, |
| 2710 VkPipelineLayout* pPipelineLayout); |
| 2711 |
| 2712 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( |
| 2713 VkDevice device, |
| 2714 VkPipelineLayout pipelineLayout, |
| 2715 const VkAllocationCallbacks* pAllocator); |
| 2716 |
| 2717 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( |
| 2718 VkDevice device, |
| 2719 const VkSamplerCreateInfo* pCreateInfo, |
| 2720 const VkAllocationCallbacks* pAllocator, |
| 2721 VkSampler* pSampler); |
| 2722 |
| 2723 VKAPI_ATTR void VKAPI_CALL vkDestroySampler( |
| 2724 VkDevice device, |
| 2725 VkSampler sampler, |
| 2726 const VkAllocationCallbacks* pAllocator); |
| 2727 |
| 2728 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( |
| 2729 VkDevice device, |
| 2730 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| 2731 const VkAllocationCallbacks* pAllocator, |
| 2732 VkDescriptorSetLayout* pSetLayout); |
| 2733 |
| 2734 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( |
| 2735 VkDevice device, |
| 2736 VkDescriptorSetLayout descriptorSetLayout, |
| 2737 const VkAllocationCallbacks* pAllocator); |
| 2738 |
| 2739 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( |
| 2740 VkDevice device, |
| 2741 const VkDescriptorPoolCreateInfo* pCreateInfo, |
| 2742 const VkAllocationCallbacks* pAllocator, |
| 2743 VkDescriptorPool* pDescriptorPool); |
| 2744 |
| 2745 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( |
| 2746 VkDevice device, |
| 2747 VkDescriptorPool descriptorPool, |
| 2748 const VkAllocationCallbacks* pAllocator); |
| 2749 |
| 2750 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( |
| 2751 VkDevice device, |
| 2752 VkDescriptorPool descriptorPool, |
| 2753 VkDescriptorPoolResetFlags flags); |
| 2754 |
| 2755 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( |
| 2756 VkDevice device, |
| 2757 const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| 2758 VkDescriptorSet* pDescriptorSets); |
| 2759 |
| 2760 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( |
| 2761 VkDevice device, |
| 2762 VkDescriptorPool descriptorPool, |
| 2763 uint32_t descriptorSetCount, |
| 2764 const VkDescriptorSet* pDescriptorSets); |
| 2765 |
| 2766 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( |
| 2767 VkDevice device, |
| 2768 uint32_t descriptorWriteCount, |
| 2769 const VkWriteDescriptorSet* pDescriptorWrites, |
| 2770 uint32_t descriptorCopyCount, |
| 2771 const VkCopyDescriptorSet* pDescriptorCopies); |
| 2772 |
| 2773 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( |
| 2774 VkDevice device, |
| 2775 const VkFramebufferCreateInfo* pCreateInfo, |
| 2776 const VkAllocationCallbacks* pAllocator, |
| 2777 VkFramebuffer* pFramebuffer); |
| 2778 |
| 2779 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( |
| 2780 VkDevice device, |
| 2781 VkFramebuffer framebuffer, |
| 2782 const VkAllocationCallbacks* pAllocator); |
| 2783 |
| 2784 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( |
| 2785 VkDevice device, |
| 2786 const VkRenderPassCreateInfo* pCreateInfo, |
| 2787 const VkAllocationCallbacks* pAllocator, |
| 2788 VkRenderPass* pRenderPass); |
| 2789 |
| 2790 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( |
| 2791 VkDevice device, |
| 2792 VkRenderPass renderPass, |
| 2793 const VkAllocationCallbacks* pAllocator); |
| 2794 |
| 2795 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( |
| 2796 VkDevice device, |
| 2797 VkRenderPass renderPass, |
| 2798 VkExtent2D* pGranularity); |
| 2799 |
| 2800 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( |
| 2801 VkDevice device, |
| 2802 const VkCommandPoolCreateInfo* pCreateInfo, |
| 2803 const VkAllocationCallbacks* pAllocator, |
| 2804 VkCommandPool* pCommandPool); |
| 2805 |
| 2806 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( |
| 2807 VkDevice device, |
| 2808 VkCommandPool commandPool, |
| 2809 const VkAllocationCallbacks* pAllocator); |
| 2810 |
| 2811 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( |
| 2812 VkDevice device, |
| 2813 VkCommandPool commandPool, |
| 2814 VkCommandPoolResetFlags flags); |
| 2815 |
| 2816 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( |
| 2817 VkDevice device, |
| 2818 const VkCommandBufferAllocateInfo* pAllocateInfo, |
| 2819 VkCommandBuffer* pCommandBuffers); |
| 2820 |
| 2821 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( |
| 2822 VkDevice device, |
| 2823 VkCommandPool commandPool, |
| 2824 uint32_t commandBufferCount, |
| 2825 const VkCommandBuffer* pCommandBuffers); |
| 2826 |
| 2827 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( |
| 2828 VkCommandBuffer commandBuffer, |
| 2829 const VkCommandBufferBeginInfo* pBeginInfo); |
| 2830 |
| 2831 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( |
| 2832 VkCommandBuffer commandBuffer); |
| 2833 |
| 2834 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( |
| 2835 VkCommandBuffer commandBuffer, |
| 2836 VkCommandBufferResetFlags flags); |
| 2837 |
| 2838 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( |
| 2839 VkCommandBuffer commandBuffer, |
| 2840 VkPipelineBindPoint pipelineBindPoint, |
| 2841 VkPipeline pipeline); |
| 2842 |
| 2843 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( |
| 2844 VkCommandBuffer commandBuffer, |
| 2845 uint32_t firstViewport, |
| 2846 uint32_t viewportCount, |
| 2847 const VkViewport* pViewports); |
| 2848 |
| 2849 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( |
| 2850 VkCommandBuffer commandBuffer, |
| 2851 uint32_t firstScissor, |
| 2852 uint32_t scissorCount, |
| 2853 const VkRect2D* pScissors); |
| 2854 |
| 2855 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( |
| 2856 VkCommandBuffer commandBuffer, |
| 2857 float lineWidth); |
| 2858 |
| 2859 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( |
| 2860 VkCommandBuffer commandBuffer, |
| 2861 float depthBiasConstantFactor, |
| 2862 float depthBiasClamp, |
| 2863 float depthBiasSlopeFactor); |
| 2864 |
| 2865 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( |
| 2866 VkCommandBuffer commandBuffer, |
| 2867 const float blendConstants[4]); |
| 2868 |
| 2869 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( |
| 2870 VkCommandBuffer commandBuffer, |
| 2871 float minDepthBounds, |
| 2872 float maxDepthBounds); |
| 2873 |
| 2874 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( |
| 2875 VkCommandBuffer commandBuffer, |
| 2876 VkStencilFaceFlags faceMask, |
| 2877 uint32_t compareMask); |
| 2878 |
| 2879 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( |
| 2880 VkCommandBuffer commandBuffer, |
| 2881 VkStencilFaceFlags faceMask, |
| 2882 uint32_t writeMask); |
| 2883 |
| 2884 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( |
| 2885 VkCommandBuffer commandBuffer, |
| 2886 VkStencilFaceFlags faceMask, |
| 2887 uint32_t reference); |
| 2888 |
| 2889 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( |
| 2890 VkCommandBuffer commandBuffer, |
| 2891 VkPipelineBindPoint pipelineBindPoint, |
| 2892 VkPipelineLayout layout, |
| 2893 uint32_t firstSet, |
| 2894 uint32_t descriptorSetCount, |
| 2895 const VkDescriptorSet* pDescriptorSets, |
| 2896 uint32_t dynamicOffsetCount, |
| 2897 const uint32_t* pDynamicOffsets); |
| 2898 |
| 2899 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( |
| 2900 VkCommandBuffer commandBuffer, |
| 2901 VkBuffer buffer, |
| 2902 VkDeviceSize offset, |
| 2903 VkIndexType indexType); |
| 2904 |
| 2905 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( |
| 2906 VkCommandBuffer commandBuffer, |
| 2907 uint32_t firstBinding, |
| 2908 uint32_t bindingCount, |
| 2909 const VkBuffer* pBuffers, |
| 2910 const VkDeviceSize* pOffsets); |
| 2911 |
| 2912 VKAPI_ATTR void VKAPI_CALL vkCmdDraw( |
| 2913 VkCommandBuffer commandBuffer, |
| 2914 uint32_t vertexCount, |
| 2915 uint32_t instanceCount, |
| 2916 uint32_t firstVertex, |
| 2917 uint32_t firstInstance); |
| 2918 |
| 2919 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( |
| 2920 VkCommandBuffer commandBuffer, |
| 2921 uint32_t indexCount, |
| 2922 uint32_t instanceCount, |
| 2923 uint32_t firstIndex, |
| 2924 int32_t vertexOffset, |
| 2925 uint32_t firstInstance); |
| 2926 |
| 2927 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( |
| 2928 VkCommandBuffer commandBuffer, |
| 2929 VkBuffer buffer, |
| 2930 VkDeviceSize offset, |
| 2931 uint32_t drawCount, |
| 2932 uint32_t stride); |
| 2933 |
| 2934 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( |
| 2935 VkCommandBuffer commandBuffer, |
| 2936 VkBuffer buffer, |
| 2937 VkDeviceSize offset, |
| 2938 uint32_t drawCount, |
| 2939 uint32_t stride); |
| 2940 |
| 2941 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( |
| 2942 VkCommandBuffer commandBuffer, |
| 2943 uint32_t x, |
| 2944 uint32_t y, |
| 2945 uint32_t z); |
| 2946 |
| 2947 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( |
| 2948 VkCommandBuffer commandBuffer, |
| 2949 VkBuffer buffer, |
| 2950 VkDeviceSize offset); |
| 2951 |
| 2952 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( |
| 2953 VkCommandBuffer commandBuffer, |
| 2954 VkBuffer srcBuffer, |
| 2955 VkBuffer dstBuffer, |
| 2956 uint32_t regionCount, |
| 2957 const VkBufferCopy* pRegions); |
| 2958 |
| 2959 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( |
| 2960 VkCommandBuffer commandBuffer, |
| 2961 VkImage srcImage, |
| 2962 VkImageLayout srcImageLayout, |
| 2963 VkImage dstImage, |
| 2964 VkImageLayout dstImageLayout, |
| 2965 uint32_t regionCount, |
| 2966 const VkImageCopy* pRegions); |
| 2967 |
| 2968 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( |
| 2969 VkCommandBuffer commandBuffer, |
| 2970 VkImage srcImage, |
| 2971 VkImageLayout srcImageLayout, |
| 2972 VkImage dstImage, |
| 2973 VkImageLayout dstImageLayout, |
| 2974 uint32_t regionCount, |
| 2975 const VkImageBlit* pRegions, |
| 2976 VkFilter filter); |
| 2977 |
| 2978 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( |
| 2979 VkCommandBuffer commandBuffer, |
| 2980 VkBuffer srcBuffer, |
| 2981 VkImage dstImage, |
| 2982 VkImageLayout dstImageLayout, |
| 2983 uint32_t regionCount, |
| 2984 const VkBufferImageCopy* pRegions); |
| 2985 |
| 2986 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( |
| 2987 VkCommandBuffer commandBuffer, |
| 2988 VkImage srcImage, |
| 2989 VkImageLayout srcImageLayout, |
| 2990 VkBuffer dstBuffer, |
| 2991 uint32_t regionCount, |
| 2992 const VkBufferImageCopy* pRegions); |
| 2993 |
| 2994 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( |
| 2995 VkCommandBuffer commandBuffer, |
| 2996 VkBuffer dstBuffer, |
| 2997 VkDeviceSize dstOffset, |
| 2998 VkDeviceSize dataSize, |
| 2999 const uint32_t* pData); |
| 3000 |
| 3001 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( |
| 3002 VkCommandBuffer commandBuffer, |
| 3003 VkBuffer dstBuffer, |
| 3004 VkDeviceSize dstOffset, |
| 3005 VkDeviceSize size, |
| 3006 uint32_t data); |
| 3007 |
| 3008 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( |
| 3009 VkCommandBuffer commandBuffer, |
| 3010 VkImage image, |
| 3011 VkImageLayout imageLayout, |
| 3012 const VkClearColorValue* pColor, |
| 3013 uint32_t rangeCount, |
| 3014 const VkImageSubresourceRange* pRanges); |
| 3015 |
| 3016 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( |
| 3017 VkCommandBuffer commandBuffer, |
| 3018 VkImage image, |
| 3019 VkImageLayout imageLayout, |
| 3020 const VkClearDepthStencilValue* pDepthStencil, |
| 3021 uint32_t rangeCount, |
| 3022 const VkImageSubresourceRange* pRanges); |
| 3023 |
| 3024 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( |
| 3025 VkCommandBuffer commandBuffer, |
| 3026 uint32_t attachmentCount, |
| 3027 const VkClearAttachment* pAttachments, |
| 3028 uint32_t rectCount, |
| 3029 const VkClearRect* pRects); |
| 3030 |
| 3031 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( |
| 3032 VkCommandBuffer commandBuffer, |
| 3033 VkImage srcImage, |
| 3034 VkImageLayout srcImageLayout, |
| 3035 VkImage dstImage, |
| 3036 VkImageLayout dstImageLayout, |
| 3037 uint32_t regionCount, |
| 3038 const VkImageResolve* pRegions); |
| 3039 |
| 3040 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( |
| 3041 VkCommandBuffer commandBuffer, |
| 3042 VkEvent event, |
| 3043 VkPipelineStageFlags stageMask); |
| 3044 |
| 3045 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( |
| 3046 VkCommandBuffer commandBuffer, |
| 3047 VkEvent event, |
| 3048 VkPipelineStageFlags stageMask); |
| 3049 |
| 3050 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( |
| 3051 VkCommandBuffer commandBuffer, |
| 3052 uint32_t eventCount, |
| 3053 const VkEvent* pEvents, |
| 3054 VkPipelineStageFlags srcStageMask, |
| 3055 VkPipelineStageFlags dstStageMask, |
| 3056 uint32_t memoryBarrierCount, |
| 3057 const VkMemoryBarrier* pMemoryBarriers, |
| 3058 uint32_t bufferMemoryBarrierCount, |
| 3059 const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| 3060 uint32_t imageMemoryBarrierCount, |
| 3061 const VkImageMemoryBarrier* pImageMemoryBarriers); |
| 3062 |
| 3063 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( |
| 3064 VkCommandBuffer commandBuffer, |
| 3065 VkPipelineStageFlags srcStageMask, |
| 3066 VkPipelineStageFlags dstStageMask, |
| 3067 VkDependencyFlags dependencyFlags, |
| 3068 uint32_t memoryBarrierCount, |
| 3069 const VkMemoryBarrier* pMemoryBarriers, |
| 3070 uint32_t bufferMemoryBarrierCount, |
| 3071 const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| 3072 uint32_t imageMemoryBarrierCount, |
| 3073 const VkImageMemoryBarrier* pImageMemoryBarriers); |
| 3074 |
| 3075 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( |
| 3076 VkCommandBuffer commandBuffer, |
| 3077 VkQueryPool queryPool, |
| 3078 uint32_t query, |
| 3079 VkQueryControlFlags flags); |
| 3080 |
| 3081 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( |
| 3082 VkCommandBuffer commandBuffer, |
| 3083 VkQueryPool queryPool, |
| 3084 uint32_t query); |
| 3085 |
| 3086 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( |
| 3087 VkCommandBuffer commandBuffer, |
| 3088 VkQueryPool queryPool, |
| 3089 uint32_t firstQuery, |
| 3090 uint32_t queryCount); |
| 3091 |
| 3092 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( |
| 3093 VkCommandBuffer commandBuffer, |
| 3094 VkPipelineStageFlagBits pipelineStage, |
| 3095 VkQueryPool queryPool, |
| 3096 uint32_t query); |
| 3097 |
| 3098 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( |
| 3099 VkCommandBuffer commandBuffer, |
| 3100 VkQueryPool queryPool, |
| 3101 uint32_t firstQuery, |
| 3102 uint32_t queryCount, |
| 3103 VkBuffer dstBuffer, |
| 3104 VkDeviceSize dstOffset, |
| 3105 VkDeviceSize stride, |
| 3106 VkQueryResultFlags flags); |
| 3107 |
| 3108 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( |
| 3109 VkCommandBuffer commandBuffer, |
| 3110 VkPipelineLayout layout, |
| 3111 VkShaderStageFlags stageFlags, |
| 3112 uint32_t offset, |
| 3113 uint32_t size, |
| 3114 const void* pValues); |
| 3115 |
| 3116 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( |
| 3117 VkCommandBuffer commandBuffer, |
| 3118 const VkRenderPassBeginInfo* pRenderPassBegin, |
| 3119 VkSubpassContents contents); |
| 3120 |
| 3121 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( |
| 3122 VkCommandBuffer commandBuffer, |
| 3123 VkSubpassContents contents); |
| 3124 |
| 3125 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( |
| 3126 VkCommandBuffer commandBuffer); |
| 3127 |
| 3128 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( |
| 3129 VkCommandBuffer commandBuffer, |
| 3130 uint32_t commandBufferCount, |
| 3131 const VkCommandBuffer* pCommandBuffers); |
| 3132 #endif |
| 3133 |
| 3134 #define VK_KHR_surface 1 |
| 3135 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) |
| 3136 |
| 3137 #define VK_KHR_SURFACE_SPEC_VERSION 25 |
| 3138 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" |
| 3139 |
| 3140 |
| 3141 typedef enum VkColorSpaceKHR { |
| 3142 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, |
| 3143 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, |
| 3144 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, |
| 3145 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE
_SRGB_NONLINEAR_KHR + 1), |
| 3146 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF |
| 3147 } VkColorSpaceKHR; |
| 3148 |
| 3149 typedef enum VkPresentModeKHR { |
| 3150 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, |
| 3151 VK_PRESENT_MODE_MAILBOX_KHR = 1, |
| 3152 VK_PRESENT_MODE_FIFO_KHR = 2, |
| 3153 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, |
| 3154 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, |
| 3155 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, |
| 3156 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_
MODE_IMMEDIATE_KHR + 1), |
| 3157 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF |
| 3158 } VkPresentModeKHR; |
| 3159 |
| 3160 |
| 3161 typedef enum VkSurfaceTransformFlagBitsKHR { |
| 3162 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, |
| 3163 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, |
| 3164 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, |
| 3165 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, |
| 3166 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, |
| 3167 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, |
| 3168 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, |
| 3169 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, |
| 3170 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, |
| 3171 } VkSurfaceTransformFlagBitsKHR; |
| 3172 typedef VkFlags VkSurfaceTransformFlagsKHR; |
| 3173 |
| 3174 typedef enum VkCompositeAlphaFlagBitsKHR { |
| 3175 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, |
| 3176 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, |
| 3177 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, |
| 3178 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, |
| 3179 } VkCompositeAlphaFlagBitsKHR; |
| 3180 typedef VkFlags VkCompositeAlphaFlagsKHR; |
| 3181 |
| 3182 typedef struct VkSurfaceCapabilitiesKHR { |
| 3183 uint32_t minImageCount; |
| 3184 uint32_t maxImageCount; |
| 3185 VkExtent2D currentExtent; |
| 3186 VkExtent2D minImageExtent; |
| 3187 VkExtent2D maxImageExtent; |
| 3188 uint32_t maxImageArrayLayers; |
| 3189 VkSurfaceTransformFlagsKHR supportedTransforms; |
| 3190 VkSurfaceTransformFlagBitsKHR currentTransform; |
| 3191 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; |
| 3192 VkImageUsageFlags supportedUsageFlags; |
| 3193 } VkSurfaceCapabilitiesKHR; |
| 3194 |
| 3195 typedef struct VkSurfaceFormatKHR { |
| 3196 VkFormat format; |
| 3197 VkColorSpaceKHR colorSpace; |
| 3198 } VkSurfaceFormatKHR; |
| 3199 |
| 3200 |
| 3201 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurface
KHR surface, const VkAllocationCallbacks* pAllocator); |
| 3202 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysica
lDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool3
2* pSupported); |
| 3203 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPh
ysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSu
rfaceCapabilities); |
| 3204 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysica
lDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkS
urfaceFormatKHR* pSurfaceFormats); |
| 3205 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPh
ysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes); |
| 3206 |
| 3207 #ifndef VK_NO_PROTOTYPES |
| 3208 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( |
| 3209 VkInstance instance, |
| 3210 VkSurfaceKHR surface, |
| 3211 const VkAllocationCallbacks* pAllocator); |
| 3212 |
| 3213 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( |
| 3214 VkPhysicalDevice physicalDevice, |
| 3215 uint32_t queueFamilyIndex, |
| 3216 VkSurfaceKHR surface, |
| 3217 VkBool32* pSupported); |
| 3218 |
| 3219 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| 3220 VkPhysicalDevice physicalDevice, |
| 3221 VkSurfaceKHR surface, |
| 3222 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); |
| 3223 |
| 3224 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( |
| 3225 VkPhysicalDevice physicalDevice, |
| 3226 VkSurfaceKHR surface, |
| 3227 uint32_t* pSurfaceFormatCount, |
| 3228 VkSurfaceFormatKHR* pSurfaceFormats); |
| 3229 |
| 3230 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( |
| 3231 VkPhysicalDevice physicalDevice, |
| 3232 VkSurfaceKHR surface, |
| 3233 uint32_t* pPresentModeCount, |
| 3234 VkPresentModeKHR* pPresentModes); |
| 3235 #endif |
| 3236 |
| 3237 #define VK_KHR_swapchain 1 |
| 3238 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) |
| 3239 |
| 3240 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 |
| 3241 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" |
| 3242 |
| 3243 typedef VkFlags VkSwapchainCreateFlagsKHR; |
| 3244 |
| 3245 typedef struct VkSwapchainCreateInfoKHR { |
| 3246 VkStructureType sType; |
| 3247 const void* pNext; |
| 3248 VkSwapchainCreateFlagsKHR flags; |
| 3249 VkSurfaceKHR surface; |
| 3250 uint32_t minImageCount; |
| 3251 VkFormat imageFormat; |
| 3252 VkColorSpaceKHR imageColorSpace; |
| 3253 VkExtent2D imageExtent; |
| 3254 uint32_t imageArrayLayers; |
| 3255 VkImageUsageFlags imageUsage; |
| 3256 VkSharingMode imageSharingMode; |
| 3257 uint32_t queueFamilyIndexCount; |
| 3258 const uint32_t* pQueueFamilyIndices; |
| 3259 VkSurfaceTransformFlagBitsKHR preTransform; |
| 3260 VkCompositeAlphaFlagBitsKHR compositeAlpha; |
| 3261 VkPresentModeKHR presentMode; |
| 3262 VkBool32 clipped; |
| 3263 VkSwapchainKHR oldSwapchain; |
| 3264 } VkSwapchainCreateInfoKHR; |
| 3265 |
| 3266 typedef struct VkPresentInfoKHR { |
| 3267 VkStructureType sType; |
| 3268 const void* pNext; |
| 3269 uint32_t waitSemaphoreCount; |
| 3270 const VkSemaphore* pWaitSemaphores; |
| 3271 uint32_t swapchainCount; |
| 3272 const VkSwapchainKHR* pSwapchains; |
| 3273 const uint32_t* pImageIndices; |
| 3274 VkResult* pResults; |
| 3275 } VkPresentInfoKHR; |
| 3276 |
| 3277 |
| 3278 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const Vk
SwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, Vk
SwapchainKHR* pSwapchain); |
| 3279 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchain
KHR swapchain, const VkAllocationCallbacks* pAllocator); |
| 3280 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwa
pchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); |
| 3281 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapc
hainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint3
2_t* pImageIndex); |
| 3282 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPrese
ntInfoKHR* pPresentInfo); |
| 3283 |
| 3284 #ifndef VK_NO_PROTOTYPES |
| 3285 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( |
| 3286 VkDevice device, |
| 3287 const VkSwapchainCreateInfoKHR* pCreateInfo, |
| 3288 const VkAllocationCallbacks* pAllocator, |
| 3289 VkSwapchainKHR* pSwapchain); |
| 3290 |
| 3291 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( |
| 3292 VkDevice device, |
| 3293 VkSwapchainKHR swapchain, |
| 3294 const VkAllocationCallbacks* pAllocator); |
| 3295 |
| 3296 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( |
| 3297 VkDevice device, |
| 3298 VkSwapchainKHR swapchain, |
| 3299 uint32_t* pSwapchainImageCount, |
| 3300 VkImage* pSwapchainImages); |
| 3301 |
| 3302 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( |
| 3303 VkDevice device, |
| 3304 VkSwapchainKHR swapchain, |
| 3305 uint64_t timeout, |
| 3306 VkSemaphore semaphore, |
| 3307 VkFence fence, |
| 3308 uint32_t* pImageIndex); |
| 3309 |
| 3310 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( |
| 3311 VkQueue queue, |
| 3312 const VkPresentInfoKHR* pPresentInfo); |
| 3313 #endif |
| 3314 |
| 3315 #define VK_KHR_display 1 |
| 3316 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) |
| 3317 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) |
| 3318 |
| 3319 #define VK_KHR_DISPLAY_SPEC_VERSION 21 |
| 3320 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" |
| 3321 |
| 3322 |
| 3323 typedef enum VkDisplayPlaneAlphaFlagBitsKHR { |
| 3324 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, |
| 3325 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, |
| 3326 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, |
| 3327 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, |
| 3328 } VkDisplayPlaneAlphaFlagBitsKHR; |
| 3329 typedef VkFlags VkDisplayModeCreateFlagsKHR; |
| 3330 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; |
| 3331 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; |
| 3332 |
| 3333 typedef struct VkDisplayPropertiesKHR { |
| 3334 VkDisplayKHR display; |
| 3335 const char* displayName; |
| 3336 VkExtent2D physicalDimensions; |
| 3337 VkExtent2D physicalResolution; |
| 3338 VkSurfaceTransformFlagsKHR supportedTransforms; |
| 3339 VkBool32 planeReorderPossible; |
| 3340 VkBool32 persistentContent; |
| 3341 } VkDisplayPropertiesKHR; |
| 3342 |
| 3343 typedef struct VkDisplayModeParametersKHR { |
| 3344 VkExtent2D visibleRegion; |
| 3345 uint32_t refreshRate; |
| 3346 } VkDisplayModeParametersKHR; |
| 3347 |
| 3348 typedef struct VkDisplayModePropertiesKHR { |
| 3349 VkDisplayModeKHR displayMode; |
| 3350 VkDisplayModeParametersKHR parameters; |
| 3351 } VkDisplayModePropertiesKHR; |
| 3352 |
| 3353 typedef struct VkDisplayModeCreateInfoKHR { |
| 3354 VkStructureType sType; |
| 3355 const void* pNext; |
| 3356 VkDisplayModeCreateFlagsKHR flags; |
| 3357 VkDisplayModeParametersKHR parameters; |
| 3358 } VkDisplayModeCreateInfoKHR; |
| 3359 |
| 3360 typedef struct VkDisplayPlaneCapabilitiesKHR { |
| 3361 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; |
| 3362 VkOffset2D minSrcPosition; |
| 3363 VkOffset2D maxSrcPosition; |
| 3364 VkExtent2D minSrcExtent; |
| 3365 VkExtent2D maxSrcExtent; |
| 3366 VkOffset2D minDstPosition; |
| 3367 VkOffset2D maxDstPosition; |
| 3368 VkExtent2D minDstExtent; |
| 3369 VkExtent2D maxDstExtent; |
| 3370 } VkDisplayPlaneCapabilitiesKHR; |
| 3371 |
| 3372 typedef struct VkDisplayPlanePropertiesKHR { |
| 3373 VkDisplayKHR currentDisplay; |
| 3374 uint32_t currentStackIndex; |
| 3375 } VkDisplayPlanePropertiesKHR; |
| 3376 |
| 3377 typedef struct VkDisplaySurfaceCreateInfoKHR { |
| 3378 VkStructureType sType; |
| 3379 const void* pNext; |
| 3380 VkDisplaySurfaceCreateFlagsKHR flags; |
| 3381 VkDisplayModeKHR displayMode; |
| 3382 uint32_t planeIndex; |
| 3383 uint32_t planeStackIndex; |
| 3384 VkSurfaceTransformFlagBitsKHR transform; |
| 3385 float globalAlpha; |
| 3386 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; |
| 3387 VkExtent2D imageExtent; |
| 3388 } VkDisplaySurfaceCreateInfoKHR; |
| 3389 |
| 3390 |
| 3391 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhys
icalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pPr
operties); |
| 3392 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(V
kPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperti
esKHR* pProperties); |
| 3393 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysic
alDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplay
KHR* pDisplays); |
| 3394 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice
physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePr
opertiesKHR* pProperties); |
| 3395 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physic
alDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, co
nst VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); |
| 3396 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDev
ice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCa
pabilitiesKHR* pCapabilities); |
| 3397 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance inst
ance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallba
cks* pAllocator, VkSurfaceKHR* pSurface); |
| 3398 |
| 3399 #ifndef VK_NO_PROTOTYPES |
| 3400 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( |
| 3401 VkPhysicalDevice physicalDevice, |
| 3402 uint32_t* pPropertyCount, |
| 3403 VkDisplayPropertiesKHR* pProperties); |
| 3404 |
| 3405 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( |
| 3406 VkPhysicalDevice physicalDevice, |
| 3407 uint32_t* pPropertyCount, |
| 3408 VkDisplayPlanePropertiesKHR* pProperties); |
| 3409 |
| 3410 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( |
| 3411 VkPhysicalDevice physicalDevice, |
| 3412 uint32_t planeIndex, |
| 3413 uint32_t* pDisplayCount, |
| 3414 VkDisplayKHR* pDisplays); |
| 3415 |
| 3416 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( |
| 3417 VkPhysicalDevice physicalDevice, |
| 3418 VkDisplayKHR display, |
| 3419 uint32_t* pPropertyCount, |
| 3420 VkDisplayModePropertiesKHR* pProperties); |
| 3421 |
| 3422 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( |
| 3423 VkPhysicalDevice physicalDevice, |
| 3424 VkDisplayKHR display, |
| 3425 const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| 3426 const VkAllocationCallbacks* pAllocator, |
| 3427 VkDisplayModeKHR* pMode); |
| 3428 |
| 3429 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( |
| 3430 VkPhysicalDevice physicalDevice, |
| 3431 VkDisplayModeKHR mode, |
| 3432 uint32_t planeIndex, |
| 3433 VkDisplayPlaneCapabilitiesKHR* pCapabilities); |
| 3434 |
| 3435 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( |
| 3436 VkInstance instance, |
| 3437 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| 3438 const VkAllocationCallbacks* pAllocator, |
| 3439 VkSurfaceKHR* pSurface); |
| 3440 #endif |
| 3441 |
| 3442 #define VK_KHR_display_swapchain 1 |
| 3443 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 |
| 3444 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" |
| 3445 |
| 3446 typedef struct VkDisplayPresentInfoKHR { |
| 3447 VkStructureType sType; |
| 3448 const void* pNext; |
| 3449 VkRect2D srcRect; |
| 3450 VkRect2D dstRect; |
| 3451 VkBool32 persistent; |
| 3452 } VkDisplayPresentInfoKHR; |
| 3453 |
| 3454 |
| 3455 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, u
int32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAl
locationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); |
| 3456 |
| 3457 #ifndef VK_NO_PROTOTYPES |
| 3458 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( |
| 3459 VkDevice device, |
| 3460 uint32_t swapchainCount, |
| 3461 const VkSwapchainCreateInfoKHR* pCreateInfos, |
| 3462 const VkAllocationCallbacks* pAllocator, |
| 3463 VkSwapchainKHR* pSwapchains); |
| 3464 #endif |
| 3465 |
| 3466 #ifdef VK_USE_PLATFORM_XLIB_KHR |
| 3467 #define VK_KHR_xlib_surface 1 |
| 3468 #include <X11/Xlib.h> |
| 3469 |
| 3470 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 |
| 3471 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" |
| 3472 |
| 3473 typedef VkFlags VkXlibSurfaceCreateFlagsKHR; |
| 3474 |
| 3475 typedef struct VkXlibSurfaceCreateInfoKHR { |
| 3476 VkStructureType sType; |
| 3477 const void* pNext; |
| 3478 VkXlibSurfaceCreateFlagsKHR flags; |
| 3479 Display* dpy; |
| 3480 Window window; |
| 3481 } VkXlibSurfaceCreateInfoKHR; |
| 3482 |
| 3483 |
| 3484 typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, co
nst VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAlloc
ator, VkSurfaceKHR* pSurface); |
| 3485 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, Visual
ID visualID); |
| 3486 |
| 3487 #ifndef VK_NO_PROTOTYPES |
| 3488 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( |
| 3489 VkInstance instance, |
| 3490 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| 3491 const VkAllocationCallbacks* pAllocator, |
| 3492 VkSurfaceKHR* pSurface); |
| 3493 |
| 3494 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( |
| 3495 VkPhysicalDevice physicalDevice, |
| 3496 uint32_t queueFamilyIndex, |
| 3497 Display* dpy, |
| 3498 VisualID visualID); |
| 3499 #endif |
| 3500 #endif /* VK_USE_PLATFORM_XLIB_KHR */ |
| 3501 |
| 3502 #ifdef VK_USE_PLATFORM_XCB_KHR |
| 3503 #define VK_KHR_xcb_surface 1 |
| 3504 #include <xcb/xcb.h> |
| 3505 |
| 3506 #define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 |
| 3507 #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" |
| 3508 |
| 3509 typedef VkFlags VkXcbSurfaceCreateFlagsKHR; |
| 3510 |
| 3511 typedef struct VkXcbSurfaceCreateInfoKHR { |
| 3512 VkStructureType sType; |
| 3513 const void* pNext; |
| 3514 VkXcbSurfaceCreateFlagsKHR flags; |
| 3515 xcb_connection_t* connection; |
| 3516 xcb_window_t window; |
| 3517 } VkXcbSurfaceCreateInfoKHR; |
| 3518 |
| 3519 |
| 3520 typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, con
st VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocat
or, VkSurfaceKHR* pSurface); |
| 3521 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(V
kPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* con
nection, xcb_visualid_t visual_id); |
| 3522 |
| 3523 #ifndef VK_NO_PROTOTYPES |
| 3524 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( |
| 3525 VkInstance instance, |
| 3526 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| 3527 const VkAllocationCallbacks* pAllocator, |
| 3528 VkSurfaceKHR* pSurface); |
| 3529 |
| 3530 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( |
| 3531 VkPhysicalDevice physicalDevice, |
| 3532 uint32_t queueFamilyIndex, |
| 3533 xcb_connection_t* connection, |
| 3534 xcb_visualid_t visual_id); |
| 3535 #endif |
| 3536 #endif /* VK_USE_PLATFORM_XCB_KHR */ |
| 3537 |
| 3538 #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| 3539 #define VK_KHR_wayland_surface 1 |
| 3540 #include <wayland-client.h> |
| 3541 |
| 3542 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5 |
| 3543 #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" |
| 3544 |
| 3545 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; |
| 3546 |
| 3547 typedef struct VkWaylandSurfaceCreateInfoKHR { |
| 3548 VkStructureType sType; |
| 3549 const void* pNext; |
| 3550 VkWaylandSurfaceCreateFlagsKHR flags; |
| 3551 struct wl_display* display; |
| 3552 struct wl_surface* surface; |
| 3553 } VkWaylandSurfaceCreateInfoKHR; |
| 3554 |
| 3555 |
| 3556 typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkSurfaceKHR* pSurface); |
| 3557 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKH
R)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display
* display); |
| 3558 |
| 3559 #ifndef VK_NO_PROTOTYPES |
| 3560 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( |
| 3561 VkInstance instance, |
| 3562 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| 3563 const VkAllocationCallbacks* pAllocator, |
| 3564 VkSurfaceKHR* pSurface); |
| 3565 |
| 3566 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( |
| 3567 VkPhysicalDevice physicalDevice, |
| 3568 uint32_t queueFamilyIndex, |
| 3569 struct wl_display* display); |
| 3570 #endif |
| 3571 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ |
| 3572 |
| 3573 #ifdef VK_USE_PLATFORM_MIR_KHR |
| 3574 #define VK_KHR_mir_surface 1 |
| 3575 #include <mir_toolkit/client_types.h> |
| 3576 |
| 3577 #define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 |
| 3578 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" |
| 3579 |
| 3580 typedef VkFlags VkMirSurfaceCreateFlagsKHR; |
| 3581 |
| 3582 typedef struct VkMirSurfaceCreateInfoKHR { |
| 3583 VkStructureType sType; |
| 3584 const void* pNext; |
| 3585 VkMirSurfaceCreateFlagsKHR flags; |
| 3586 MirConnection* connection; |
| 3587 MirSurface* mirSurface; |
| 3588 } VkMirSurfaceCreateInfoKHR; |
| 3589 |
| 3590 |
| 3591 typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, con
st VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocat
or, VkSurfaceKHR* pSurface); |
| 3592 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(V
kPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connec
tion); |
| 3593 |
| 3594 #ifndef VK_NO_PROTOTYPES |
| 3595 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( |
| 3596 VkInstance instance, |
| 3597 const VkMirSurfaceCreateInfoKHR* pCreateInfo, |
| 3598 const VkAllocationCallbacks* pAllocator, |
| 3599 VkSurfaceKHR* pSurface); |
| 3600 |
| 3601 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( |
| 3602 VkPhysicalDevice physicalDevice, |
| 3603 uint32_t queueFamilyIndex, |
| 3604 MirConnection* connection); |
| 3605 #endif |
| 3606 #endif /* VK_USE_PLATFORM_MIR_KHR */ |
| 3607 |
| 3608 #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| 3609 #define VK_KHR_android_surface 1 |
| 3610 #include <android/native_window.h> |
| 3611 |
| 3612 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 |
| 3613 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" |
| 3614 |
| 3615 typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; |
| 3616 |
| 3617 typedef struct VkAndroidSurfaceCreateInfoKHR { |
| 3618 VkStructureType sType; |
| 3619 const void* pNext; |
| 3620 VkAndroidSurfaceCreateFlagsKHR flags; |
| 3621 ANativeWindow* window; |
| 3622 } VkAndroidSurfaceCreateInfoKHR; |
| 3623 |
| 3624 |
| 3625 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkSurfaceKHR* pSurface); |
| 3626 |
| 3627 #ifndef VK_NO_PROTOTYPES |
| 3628 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( |
| 3629 VkInstance instance, |
| 3630 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| 3631 const VkAllocationCallbacks* pAllocator, |
| 3632 VkSurfaceKHR* pSurface); |
| 3633 #endif |
| 3634 #endif /* VK_USE_PLATFORM_ANDROID_KHR */ |
| 3635 |
| 3636 #ifdef VK_USE_PLATFORM_WIN32_KHR |
| 3637 #define VK_KHR_win32_surface 1 |
| 3638 #include <windows.h> |
| 3639 |
| 3640 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 |
| 3641 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" |
| 3642 |
| 3643 typedef VkFlags VkWin32SurfaceCreateFlagsKHR; |
| 3644 |
| 3645 typedef struct VkWin32SurfaceCreateInfoKHR { |
| 3646 VkStructureType sType; |
| 3647 const void* pNext; |
| 3648 VkWin32SurfaceCreateFlagsKHR flags; |
| 3649 HINSTANCE hinstance; |
| 3650 HWND hwnd; |
| 3651 } VkWin32SurfaceCreateInfoKHR; |
| 3652 |
| 3653 |
| 3654 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, c
onst VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAll
ocator, VkSurfaceKHR* pSurface); |
| 3655 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)
(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); |
| 3656 |
| 3657 #ifndef VK_NO_PROTOTYPES |
| 3658 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( |
| 3659 VkInstance instance, |
| 3660 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| 3661 const VkAllocationCallbacks* pAllocator, |
| 3662 VkSurfaceKHR* pSurface); |
| 3663 |
| 3664 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( |
| 3665 VkPhysicalDevice physicalDevice, |
| 3666 uint32_t queueFamilyIndex); |
| 3667 #endif |
| 3668 #endif /* VK_USE_PLATFORM_WIN32_KHR */ |
| 3669 |
| 3670 #define VK_EXT_debug_report 1 |
| 3671 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) |
| 3672 |
| 3673 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 1 |
| 3674 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" |
| 3675 |
| 3676 |
| 3677 typedef enum VkDebugReportObjectTypeEXT { |
| 3678 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, |
| 3679 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, |
| 3680 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, |
| 3681 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, |
| 3682 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, |
| 3683 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, |
| 3684 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, |
| 3685 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, |
| 3686 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, |
| 3687 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, |
| 3688 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, |
| 3689 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, |
| 3690 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, |
| 3691 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, |
| 3692 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, |
| 3693 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, |
| 3694 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, |
| 3695 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, |
| 3696 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, |
| 3697 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, |
| 3698 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, |
| 3699 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, |
| 3700 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, |
| 3701 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, |
| 3702 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, |
| 3703 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, |
| 3704 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, |
| 3705 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, |
| 3706 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, |
| 3707 } VkDebugReportObjectTypeEXT; |
| 3708 |
| 3709 typedef enum VkDebugReportErrorEXT { |
| 3710 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, |
| 3711 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, |
| 3712 } VkDebugReportErrorEXT; |
| 3713 |
| 3714 |
| 3715 typedef enum VkDebugReportFlagBitsEXT { |
| 3716 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, |
| 3717 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, |
| 3718 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, |
| 3719 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, |
| 3720 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, |
| 3721 } VkDebugReportFlagBitsEXT; |
| 3722 typedef VkFlags VkDebugReportFlagsEXT; |
| 3723 |
| 3724 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( |
| 3725 VkDebugReportFlagsEXT flags, |
| 3726 VkDebugReportObjectTypeEXT objectType, |
| 3727 uint64_t object, |
| 3728 size_t location, |
| 3729 int32_t messageCode, |
| 3730 const char* pLayerPrefix, |
| 3731 const char* pMessage, |
| 3732 void* pUserData); |
| 3733 |
| 3734 |
| 3735 typedef struct VkDebugReportCallbackCreateInfoEXT { |
| 3736 VkStructureType sType; |
| 3737 const void* pNext; |
| 3738 VkDebugReportFlagsEXT flags; |
| 3739 PFN_vkDebugReportCallbackEXT pfnCallback; |
| 3740 void* pUserData; |
| 3741 } VkDebugReportCallbackCreateInfoEXT; |
| 3742 |
| 3743 |
| 3744 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance inst
ance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationC
allbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); |
| 3745 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instanc
e, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); |
| 3746 typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDeb
ugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object,
size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMes
sage); |
| 3747 |
| 3748 #ifndef VK_NO_PROTOTYPES |
| 3749 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( |
| 3750 VkInstance instance, |
| 3751 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| 3752 const VkAllocationCallbacks* pAllocator, |
| 3753 VkDebugReportCallbackEXT* pCallback); |
| 3754 |
| 3755 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( |
| 3756 VkInstance instance, |
| 3757 VkDebugReportCallbackEXT callback, |
| 3758 const VkAllocationCallbacks* pAllocator); |
| 3759 |
| 3760 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( |
| 3761 VkInstance instance, |
| 3762 VkDebugReportFlagsEXT flags, |
| 3763 VkDebugReportObjectTypeEXT objectType, |
| 3764 uint64_t object, |
| 3765 size_t location, |
| 3766 int32_t messageCode, |
| 3767 const char* pLayerPrefix, |
| 3768 const char* pMessage); |
| 3769 #endif |
| 3770 |
| 3771 #ifdef __cplusplus |
| 3772 } |
| 3773 #endif |
| 3774 |
| 3775 #endif |
OLD | NEW |